com.gemstone.gemfire.internal.cache.execute.StreamingFunctionOperation Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
SnappyData store based off Pivotal GemFireXD
The newest version!
/*
 * Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you
 * may not use this file except in compliance with the License. You
 * may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * permissions and limitations under the License. See accompanying
 * LICENSE file.
 */
package com.gemstone.gemfire.internal.cache.execute;

import java.util.Collections;
import java.util.HashMap;
import java.util.Set;

import com.gemstone.gemfire.cache.execute.Function;
import com.gemstone.gemfire.cache.execute.ResultCollector;
import com.gemstone.gemfire.cache.execute.ResultSender;
import com.gemstone.gemfire.distributed.DistributedMember;
import com.gemstone.gemfire.distributed.internal.DistributionMessage;
import com.gemstone.gemfire.distributed.internal.InternalDistributedSystem;
import com.gemstone.gemfire.distributed.internal.membership.InternalDistributedMember;
import com.gemstone.gemfire.i18n.LogWriterI18n;

/**
 * 
 * @author ymahajan
 * 
 */
public abstract class StreamingFunctionOperation {

  protected final InternalDistributedSystem sys;

  protected Set recipients = null;

  protected ResultCollector rc;

  protected Function functionObject;

  protected HashMap memberArgs;

  protected ResultSender resultSender = null;

  protected ResultCollector reply;

  protected int totalLastMsgRecieved = 0;

  protected LogWriterI18n logger = null;

  /** Creates a new instance of StreamingOperation */
  public StreamingFunctionOperation(InternalDistributedSystem sys,
      ResultCollector rc, Function function,
      final HashMap memberArgs,
      Set recipients, ResultSender resultSender) {
    this.sys = sys;
    this.logger = this.sys.getLogWriterI18n();
    this.rc = rc;
    this.functionObject = function;
    this.memberArgs = memberArgs;
    this.recipients = recipients;
    this.resultSender = resultSender;
  }

  /** Creates a new instance of StreamingOperation */
  public StreamingFunctionOperation(InternalDistributedSystem sys,
      ResultCollector rc, Function function, ResultSender resultSender) {
    this.sys = sys;
    this.logger = this.sys.getLogWriterI18n();
    this.rc = rc;
    this.functionObject = function;
    this.resultSender = resultSender;
  }

  public void processData(Object result, boolean lastMsg,
      DistributedMember memberID) {
    boolean completelyDone = false;
    if (lastMsg) {
      this.totalLastMsgRecieved++;
    }
    if (this.totalLastMsgRecieved == this.recipients.size()) {
      completelyDone = true;
    }

    if (resultSender instanceof MemberFunctionResultSender) {
      MemberFunctionResultSender rs = (MemberFunctionResultSender)resultSender;
      rs.lastResult(result, completelyDone, this.reply, memberID);
    }
    else {
      if (completelyDone) {
        ((DistributedRegionFunctionResultSender)resultSender).lastResult(
            result, memberID);
      }
      else {
        ((DistributedRegionFunctionResultSender)resultSender).sendResult(
            result, memberID);
      }
    }
  }

  public ResultCollector getFunctionResultFrom(Set recipients,
      Function function, AbstractExecution execution) {
    if (recipients.isEmpty())
      return rc;

    FunctionStreamingResultCollector processor = new FunctionStreamingResultCollector(
        this, this.sys, recipients, rc, function, execution);
    this.reply = processor;
    for (InternalDistributedMember recip : this.memberArgs.keySet()) {
      DistributionMessage m = null;
      if (execution instanceof DistributedRegionFunctionExecutor
          || execution instanceof MultiRegionFunctionExecutor) {
        m = createRequestMessage(Collections.singleton(recip), processor,
            execution.isReExecute(), execution.isFnSerializationReqd());
      }
      else {
        m = createRequestMessage(Collections.singleton(recip), processor,
            false, execution.isFnSerializationReqd());
      }
      this.sys.getDistributionManager().putOutgoing(m);
    }
    return processor;
  }

  protected abstract DistributionMessage createRequestMessage(
      Set singleton,
      FunctionStreamingResultCollector processor, boolean isReExecute,
      boolean isFnSerializationReqd); 
}