* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you 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.

*/

* The read and write calls use ReadWriteLock for concurrency.

*/

  EventHandler<VertexEvent> {

  private static final String LINE_SEPARATOR = System

      .getProperty("line.separator");

  private static final Log LOG = LogFactory.getLog(VertexImpl.class);

  //final fields

  private final Clock clock;

  private final Lock readLock;

  private final Lock writeLock;

  private final TaskAttemptListener taskAttemptListener;

  private final TaskHeartbeatHandler taskHeartbeatHandler;

  private final Object tasksSyncHandle = new Object();

  private final EventHandler eventHandler;

  // TODO Metrics

  //private final MRAppMetrics metrics;

  private final AppContext appContext;

  private boolean lazyTasksCopyNeeded = false;

  // must be a linked map for ordering

  volatile LinkedHashMap<TezTaskID, Task> tasks = new LinkedHashMap<TezTaskID, Task>();

  private Object fullCountersLock = new Object();

  private TezCounters fullCounters = null;

  private Resource taskResource;

  private Configuration conf;

  //fields initialized in init

  private int numStartedSourceVertices = 0;

  private int numInitedSourceVertices = 0;

  private int distanceFromRoot = 0;

  private final List<String> diagnostics = new ArrayList<String>();

 

  //task/attempt related datastructures

  @VisibleForTesting

  int numSuccessSourceAttemptCompletions = 0;

  List<InputSpec> inputSpecList;

  List<OutputSpec> outputSpecList;

  List<GroupInputSpec> groupInputSpecList;

  Set<String> sharedOutputs = Sets.newHashSet();

  private static final InternalErrorTransition

      INTERNAL_ERROR_TRANSITION = new InternalErrorTransition();

  private static final RouteEventTransition

      ROUTE_EVENT_TRANSITION = new RouteEventTransition();

  private static final TaskAttemptCompletedEventTransition

      TASK_ATTEMPT_COMPLETED_EVENT_TRANSITION =

          new TaskAttemptCompletedEventTransition();

  private static final SourceTaskAttemptCompletedEventTransition

      SOURCE_TASK_ATTEMPT_COMPLETED_EVENT_TRANSITION =

          new SourceTaskAttemptCompletedEventTransition();

  protected static final

    StateMachineFactory<VertexImpl, VertexState, VertexEventType, VertexEvent>

       stateMachineFactory

     = new StateMachineFactory<VertexImpl, VertexState, VertexEventType, VertexEvent>

              (VertexState.NEW)

          // Transitions from NEW state

          .addTransition

              (VertexState.NEW,

              EnumSet.of(VertexState.NEW, VertexState.INITED,

                  VertexState.INITIALIZING, VertexState.FAILED),

              VertexEventType.V_INIT,

              new InitTransition())

          .addTransition(VertexState.NEW, VertexState.NEW,

              VertexEventType.V_SOURCE_VERTEX_STARTED,

              new SourceVertexStartedTransition())

          .addTransition(VertexState.NEW, VertexState.KILLED,

              VertexEventType.V_TERMINATE,

              new TerminateNewVertexTransition())

          .addTransition(VertexState.NEW, VertexState.ERROR,

              VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          // Transitions from INITIALIZING state

          .addTransition(VertexState.INITIALIZING,

              EnumSet.of(VertexState.INITIALIZING, VertexState.INITED,

                  VertexState.RUNNING, VertexState.FAILED),

              VertexEventType.V_ROOT_INPUT_INITIALIZED,

              new RootInputInitializedTransition())

          .addTransition(VertexState.INITIALIZING,

              EnumSet.of(VertexState.FAILED, VertexState.INITED),

              VertexEventType.V_ONE_TO_ONE_SOURCE_SPLIT,

              new OneToOneSourceSplitTransition())

          .addTransition(VertexState.INITIALIZING, VertexState.FAILED,

              VertexEventType.V_ROOT_INPUT_FAILED,

              new RootInputInitFailedTransition())

          .addTransition(VertexState.INITIALIZING, VertexState.INITIALIZING,

              VertexEventType.V_START,

              new StartWhileInitializingTransition())

          .addTransition(VertexState.INITIALIZING, VertexState.INITIALIZING,

              VertexEventType.V_SOURCE_VERTEX_STARTED,

              new SourceVertexStartedTransition())

          .addTransition(VertexState.INITIALIZING,  VertexState.INITIALIZING,

              VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

              SOURCE_TASK_ATTEMPT_COMPLETED_EVENT_TRANSITION)

          .addTransition(VertexState.INITIALIZING, VertexState.INITIALIZING,

              VertexEventType.V_ROUTE_EVENT,

              new RouteEventsWhileInitializingTransition())

          .addTransition(VertexState.INITIALIZING, VertexState.KILLED,

              VertexEventType.V_TERMINATE,

              new TerminateInitingVertexTransition())

          .addTransition(VertexState.INITIALIZING, VertexState.ERROR,

              VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          // Transitions from INITED state

          // SOURCE_VERTEX_STARTED - for sources which determine parallelism,

          // they must complete before this vertex can start.

          .addTransition(VertexState.INITED, VertexState.INITED,

              VertexEventType.V_SOURCE_VERTEX_STARTED,

              new SourceVertexStartedTransition())

          .addTransition(VertexState.INITED,

              EnumSet.of(VertexState.INITED),

              VertexEventType.V_ONE_TO_ONE_SOURCE_SPLIT,

              new OneToOneSourceSplitTransition())

          .addTransition(VertexState.INITED,  VertexState.INITED,

              VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

              SOURCE_TASK_ATTEMPT_COMPLETED_EVENT_TRANSITION)

          .addTransition(VertexState.INITED, VertexState.RUNNING,

              VertexEventType.V_START,

              new StartTransition())

          .addTransition(VertexState.INITED,

              VertexState.INITED, VertexEventType.V_ROUTE_EVENT,

              ROUTE_EVENT_TRANSITION)

          .addTransition(VertexState.INITED, VertexState.KILLED,

              VertexEventType.V_TERMINATE,

              new TerminateInitedVertexTransition())

          .addTransition(VertexState.INITED, VertexState.ERROR,

              VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          // Transitions from RUNNING state

          .addTransition(VertexState.RUNNING, VertexState.RUNNING,

              VertexEventType.V_TASK_ATTEMPT_COMPLETED,

              TASK_ATTEMPT_COMPLETED_EVENT_TRANSITION)

          .addTransition(VertexState.RUNNING, VertexState.RUNNING,

              VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

              SOURCE_TASK_ATTEMPT_COMPLETED_EVENT_TRANSITION)

          .addTransition

              (VertexState.RUNNING,

              EnumSet.of(VertexState.RUNNING,

                  VertexState.SUCCEEDED, VertexState.TERMINATING, VertexState.FAILED),

              VertexEventType.V_TASK_COMPLETED,

              new TaskCompletedTransition())

          .addTransition(VertexState.RUNNING, VertexState.TERMINATING,

              VertexEventType.V_TERMINATE,

              new VertexKilledTransition())

          .addTransition(VertexState.RUNNING, VertexState.RUNNING,

              VertexEventType.V_TASK_RESCHEDULED,

              new TaskRescheduledTransition())

          .addTransition(VertexState.RUNNING,

              EnumSet.of(VertexState.RUNNING, VertexState.SUCCEEDED,

                  VertexState.FAILED),

              VertexEventType.V_COMPLETED,

              new VertexNoTasksCompletedTransition())

          .addTransition(

              VertexState.RUNNING,

              VertexState.ERROR, VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          .addTransition(

              VertexState.RUNNING,

              VertexState.RUNNING, VertexEventType.V_ROUTE_EVENT,

              ROUTE_EVENT_TRANSITION)

          // Transitions from TERMINATING state.

          .addTransition

              (VertexState.TERMINATING,

              EnumSet.of(VertexState.TERMINATING, VertexState.KILLED, VertexState.FAILED),

              VertexEventType.V_TASK_COMPLETED,

              new TaskCompletedTransition())

          .addTransition(

              VertexState.TERMINATING,

              VertexState.ERROR, VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          // Ignore-able events

          .addTransition(VertexState.TERMINATING, VertexState.TERMINATING,

              EnumSet.of(VertexEventType.V_TERMINATE,

                  VertexEventType.V_SOURCE_VERTEX_STARTED,

                  VertexEventType.V_ROUTE_EVENT,

                  VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_TASK_RESCHEDULED))

          // Transitions from SUCCEEDED state

          .addTransition(

              VertexState.SUCCEEDED,

              VertexState.ERROR, VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          .addTransition(VertexState.SUCCEEDED,

              EnumSet.of(VertexState.RUNNING, VertexState.FAILED),

              VertexEventType.V_TASK_RESCHEDULED,

              new TaskRescheduledAfterVertexSuccessTransition())

          // Ignore-able events

          .addTransition(

              VertexState.SUCCEEDED, VertexState.SUCCEEDED,

              // accumulate these in case we get restarted

              VertexEventType.V_ROUTE_EVENT,

              ROUTE_EVENT_TRANSITION)

          .addTransition(VertexState.SUCCEEDED, VertexState.SUCCEEDED,

              EnumSet.of(VertexEventType.V_TERMINATE,

                  VertexEventType.V_TASK_ATTEMPT_COMPLETED,

                  // after we are done reruns of source tasks should not affect

                  // us. These reruns may be triggered by other consumer vertices.

                  // We should have been in RUNNING state if we had triggered the

                  // reruns.

                  VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_TASK_COMPLETED))

          // Transitions from FAILED state

          .addTransition(

              VertexState.FAILED,

              VertexState.ERROR, VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          // Ignore-able events

          .addTransition(VertexState.FAILED, VertexState.FAILED,

              EnumSet.of(VertexEventType.V_TERMINATE,

                  VertexEventType.V_SOURCE_VERTEX_STARTED,

                  VertexEventType.V_TASK_RESCHEDULED,

                  VertexEventType.V_START,

                  VertexEventType.V_ROUTE_EVENT,

                  VertexEventType.V_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_TASK_COMPLETED,

                  VertexEventType.V_ONE_TO_ONE_SOURCE_SPLIT,

                  VertexEventType.V_ROOT_INPUT_INITIALIZED,

                  VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_ROOT_INPUT_FAILED))

          // Transitions from KILLED state

          .addTransition(

              VertexState.KILLED,

              VertexState.ERROR, VertexEventType.V_INTERNAL_ERROR,

              INTERNAL_ERROR_TRANSITION)

          // Ignore-able events

          .addTransition(VertexState.KILLED, VertexState.KILLED,

              EnumSet.of(VertexEventType.V_TERMINATE,

                  VertexEventType.V_INIT,

                  VertexEventType.V_SOURCE_VERTEX_STARTED,

                  VertexEventType.V_START,

                  VertexEventType.V_ROUTE_EVENT,

                  VertexEventType.V_TASK_RESCHEDULED,

                  VertexEventType.V_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_ONE_TO_ONE_SOURCE_SPLIT,

                  VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_TASK_COMPLETED,

                  VertexEventType.V_ROOT_INPUT_INITIALIZED,

                  VertexEventType.V_ROOT_INPUT_FAILED))

          // No transitions from INTERNAL_ERROR state. Ignore all.

          .addTransition(

              VertexState.ERROR,

              VertexState.ERROR,

              EnumSet.of(VertexEventType.V_INIT,

                  VertexEventType.V_SOURCE_VERTEX_STARTED,

                  VertexEventType.V_START,

                  VertexEventType.V_ROUTE_EVENT,

                  VertexEventType.V_TERMINATE,

                  VertexEventType.V_TASK_COMPLETED,

                  VertexEventType.V_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_ONE_TO_ONE_SOURCE_SPLIT,

                  VertexEventType.V_SOURCE_TASK_ATTEMPT_COMPLETED,

                  VertexEventType.V_TASK_RESCHEDULED,

                  VertexEventType.V_INTERNAL_ERROR,

                  VertexEventType.V_ROOT_INPUT_INITIALIZED,

                  VertexEventType.V_ROOT_INPUT_FAILED))

          // create the topology tables

          .installTopology();

  private final StateMachine<VertexState, VertexEventType, VertexEvent>

      stateMachine;

  //changing fields while the vertex is running

  private int numTasks;

  private int completedTaskCount = 0;

  private int succeededTaskCount = 0;

  private int failedTaskCount = 0;

  private int killedTaskCount = 0;

  private long initTimeRequested; // Time at which INIT request was received.

  private long initedTime; // Time when entering state INITED

  private long startTimeRequested; // Time at which START request was received.

  private long startedTime; // Time when entering state STARTED

  private long finishTime;

  private float progress;

  private final TezVertexID vertexId;  //runtime assigned id.

  private final VertexPlan vertexPlan;

  private final String vertexName;

  private final ProcessorDescriptor processorDescriptor;

  @VisibleForTesting

  Map<Vertex, Edge> sourceVertices;

  private Map<Vertex, Edge> targetVertices;

  private Map<String, RootInputLeafOutputDescriptor<InputDescriptor>> additionalInputs;

  private Map<String, RootInputLeafOutputDescriptor<OutputDescriptor>> additionalOutputs;

  private Map<String, OutputCommitter> outputCommitters;

  private final List<InputSpec> additionalInputSpecs = new ArrayList<InputSpec>();

  private final List<OutputSpec> additionalOutputSpecs = new ArrayList<OutputSpec>();

  private Set<String> inputsWithInitializers;

  private int numInitializedInputs;

  private boolean startSignalPending = false;

  List<TezEvent> pendingRouteEvents = null;

  List<TezTaskAttemptID> pendingReportedSrcCompletions = Lists.newLinkedList();

  private RootInputInitializerRunner rootInputInitializer;

  private VertexManager vertexManager;

 

  private final UserGroupInformation dagUgi;

  private boolean parallelismSet = false;

  private TezVertexID originalOneToOneSplitSource = null;

  private AtomicBoolean committed = new AtomicBoolean(false);

  private AtomicBoolean aborted = new AtomicBoolean(false);

  private boolean commitVertexOutputs = false;

 

  private Map<String, VertexGroupInfo> dagVertexGroups;

 

  private VertexLocationHint vertexLocationHint;

  private Map<String, LocalResource> localResources;

  private Map<String, String> environment;

  private final String javaOpts;

  private final ContainerContext containerContext;

  private VertexTerminationCause terminationCause;

 

  private String logIdentifier;

  public VertexImpl(TezVertexID vertexId, VertexPlan vertexPlan,

      String vertexName, Configuration conf, EventHandler eventHandler,

      TaskAttemptListener taskAttemptListener, Clock clock,

      TaskHeartbeatHandler thh, boolean commitVertexOutputs,

      AppContext appContext, VertexLocationHint vertexLocationHint,

      Map<String, VertexGroupInfo> dagVertexGroups) {

    this.vertexId = vertexId;

    this.vertexPlan = vertexPlan;

    this.vertexName = StringInterner.weakIntern(vertexName);

    this.conf = conf;

    this.clock = clock;

    this.appContext = appContext;

    this.commitVertexOutputs = commitVertexOutputs;

    this.taskAttemptListener = taskAttemptListener;

    this.taskHeartbeatHandler = thh;

    this.eventHandler = eventHandler;

    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    this.readLock = readWriteLock.readLock();

    this.writeLock = readWriteLock.writeLock();

    this.vertexLocationHint = vertexLocationHint;

    if (LOG.isDebugEnabled()) {

      logLocationHints(this.vertexLocationHint);

    }

    this.dagUgi = appContext.getCurrentDAG().getDagUGI();

    this.taskResource = DagTypeConverters

        .createResourceRequestFromTaskConfig(vertexPlan.getTaskConfig());

    this.processorDescriptor = DagTypeConverters

        .convertProcessorDescriptorFromDAGPlan(vertexPlan

            .getProcessorDescriptor());

    this.localResources = DagTypeConverters

        .createLocalResourceMapFromDAGPlan(vertexPlan.getTaskConfig()

            .getLocalResourceList());

    this.localResources.putAll(appContext.getSessionResources());

    this.environment = DagTypeConverters

        .createEnvironmentMapFromDAGPlan(vertexPlan.getTaskConfig()

            .getEnvironmentSettingList());

    this.javaOpts = vertexPlan.getTaskConfig().hasJavaOpts() ? vertexPlan

        .getTaskConfig().getJavaOpts() : null;

    this.containerContext = new ContainerContext(this.localResources,

        appContext.getCurrentDAG().getCredentials(), this.environment, this.javaOpts, this);

    if (vertexPlan.getInputsCount() > 0) {

      setAdditionalInputs(vertexPlan.getInputsList());

    }

    if (vertexPlan.getOutputsCount() > 0) {

      setAdditionalOutputs(vertexPlan.getOutputsList());

    }

   

    this.dagVertexGroups = dagVertexGroups;

    logIdentifier =  this.getVertexId() + " [" + this.getName() + "]";

    // This "this leak" is okay because the retained pointer is in an

    //  instance variable.

    stateMachine = stateMachineFactory.make(this);

  }

  protected StateMachine<VertexState, VertexEventType, VertexEvent> getStateMachine() {

    return stateMachine;

  }

  @Override

  public TezVertexID getVertexId() {

    return vertexId;

  }

  @Override

  public VertexPlan getVertexPlan() {

    return vertexPlan;

  }

  @Override

  public int getDistanceFromRoot() {

    return distanceFromRoot;

  }

  @Override

  public String getName() {

    return vertexName;

  }

  EventHandler getEventHandler() {

    return this.eventHandler;

  }

  @Override

  public Task getTask(TezTaskID taskID) {

    readLock.lock();

    try {

      return tasks.get(taskID);

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public Task getTask(int taskIndex) {

    readLock.lock();

    try {

      // does it matter to create a duplicate list for efficiency

      // instead of traversing the map

      // local assign to LinkedHashMap to ensure that sequential traversal

      // assumption is satisfied

      LinkedHashMap<TezTaskID, Task> taskList = tasks;

      int i=0;

      for(Map.Entry<TezTaskID, Task> entry : taskList.entrySet()) {

        if(taskIndex == i) {

          return entry.getValue();

        }

        ++i;

      }

      return null;

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public int getTotalTasks() {

    return numTasks;

  }

  @Override

  public int getCompletedTasks() {

    readLock.lock();

    try {

      return succeededTaskCount + failedTaskCount + killedTaskCount;

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public int getSucceededTasks() {

    readLock.lock();

    try {

      return succeededTaskCount;

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public int getRunningTasks() {

    readLock.lock();

    try {

      int num=0;

      for (Task task : tasks.values()) {

        if(task.getState() == TaskState.RUNNING)

          num++;

      }

      return num;

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public TezCounters getAllCounters() {

    readLock.lock();

    try {

      VertexState state = getInternalState();

      if (state == VertexState.ERROR || state == VertexState.FAILED

          || state == VertexState.KILLED || state == VertexState.SUCCEEDED) {

        this.mayBeConstructFinalFullCounters();

        return fullCounters;

      }

      TezCounters counters = new TezCounters();

      return incrTaskCounters(counters, tasks.values());

    } finally {

      readLock.unlock();

    }

  }

  public static TezCounters incrTaskCounters(

      TezCounters counters, Collection<Task> tasks) {

    for (Task task : tasks) {

      counters.incrAllCounters(task.getCounters());

    }

    return counters;

  }

  @Override

  public List<String> getDiagnostics() {

    readLock.lock();

    try {

      return diagnostics;

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public float getProgress() {

    this.readLock.lock();

    try {

      computeProgress();

      return progress;

    } finally {

      this.readLock.unlock();

    }

  }

  @Override

  public ProgressBuilder getVertexProgress() {

    this.readLock.lock();

    try {

      ProgressBuilder progress = new ProgressBuilder();

      progress.setTotalTaskCount(numTasks);

      progress.setSucceededTaskCount(succeededTaskCount);

      progress.setRunningTaskCount(getRunningTasks());

      progress.setFailedTaskCount(failedTaskCount);

      progress.setKilledTaskCount(killedTaskCount);

      return progress;

    } finally {

      this.readLock.unlock();

    }

  }

  @Override

  public VertexStatusBuilder getVertexStatus(

      Set<StatusGetOpts> statusOptions) {

    this.readLock.lock();

    try {

      VertexStatusBuilder status = new VertexStatusBuilder();

      status.setState(getInternalState());

      status.setDiagnostics(diagnostics);

      status.setProgress(getVertexProgress());

      if (statusOptions.contains(StatusGetOpts.GET_COUNTERS)) {

        status.setVertexCounters(getAllCounters());

      }

      return status;

    } finally {

      this.readLock.unlock();

    }

  }

  private void computeProgress() {

    this.readLock.lock();

    try {

      float progress = 0f;

      for (Task task : this.tasks.values()) {

        progress += (task.isFinished() ? 1f : task.getProgress());

      }

      if (this.numTasks != 0) {

        progress /= this.numTasks;

      }

      this.progress = progress;

    } finally {

      this.readLock.unlock();

    }

  }

  @Override

  public Map<TezTaskID, Task> getTasks() {

    synchronized (tasksSyncHandle) {

      lazyTasksCopyNeeded = true;

      return Collections.unmodifiableMap(tasks);

    }

  }

  @Override

  public VertexState getState() {

    readLock.lock();

    try {

      return getStateMachine().getCurrentState();

    } finally {

      readLock.unlock();

    }

  }

  /**

   * Set the terminationCause if it had not yet been set.

   *

   * @param trigger The trigger

   * @return true if setting the value succeeded.

   */

  boolean trySetTerminationCause(VertexTerminationCause trigger) {

    if(terminationCause == null){

      terminationCause = trigger;

      return true;

    }

    return false;

  }

  @Override

  public VertexTerminationCause getTerminationCause(){

    readLock.lock();

    try {

      return terminationCause;

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public AppContext getAppContext() {

    return this.appContext;

  }

  // TODO Create InputReadyVertexManager that schedules when there is something

  // to read and use that as default instead of ImmediateStart.TEZ-480

  @Override

  public void scheduleTasks(List<Integer> taskIDs) {

    readLock.lock();

    try {

      for (Integer taskID : taskIDs) {

        if (tasks.size() <= taskID.intValue()) {

          throw new TezUncheckedException(

              "Invalid taskId: " + taskID + " for vertex: " + vertexName);

        }

        eventHandler.handle(new TaskEvent(

            TezTaskID.getInstance(vertexId, taskID.intValue()),

            TaskEventType.T_SCHEDULE));

      }

    } finally {

      readLock.unlock();

    }

  }

  @Override

  public boolean setParallelism(int parallelism, VertexLocationHint vertexLocationHint,

      Map<String, EdgeManagerDescriptor> sourceEdgeManagers) {

    writeLock.lock();

    setVertexLocationHint(vertexLocationHint);

    try {

      if (parallelismSet == true) {

        LOG.info("Parallelism can only be set dynamically once per vertex");

        return false;

      }

     

      parallelismSet = true;

      // Input initializer expected to set parallelism.

      if (numTasks == -1) {

        this.numTasks = parallelism;

        this.createTasks();

        LOG.info("Vertex " + getVertexId() +

            " parallelism set to " + parallelism);

        if(sourceEdgeManagers != null) {

          for(Map.Entry<String, EdgeManagerDescriptor> entry : sourceEdgeManagers.entrySet()) {

            LOG.info("Replacing edge manager for source:"

                + entry.getKey() + " destination: " + getVertexId());

            Vertex sourceVertex = appContext.getCurrentDAG().getVertex(entry.getKey());

            Edge edge = sourceVertices.get(sourceVertex);

            try {

              edge.setCustomEdgeManager(entry.getValue());

            } catch (Exception e) {

              LOG.warn("Failed to initialize edge manager for edge"

                  + ", sourceVertexName=" + sourceVertex.getName()

                  + ", destinationVertexName=" + edge.getDestinationVertexName(),

                  e);

              return false;

            }

          }

        }

      } else {

        if (parallelism >= numTasks) {

          // not that hard to support perhaps. but checking right now since there

          // is no use case for it and checking may catch other bugs.

          LOG.warn("Increasing parallelism is not supported, vertexId="

              + logIdentifier);

          return false;

        }

        if (parallelism == numTasks) {

          LOG.info("setParallelism same as current value: " + parallelism);

          Preconditions

          .checkArgument(sourceEdgeManagers != null,

              "Source edge managers must be set when not changing parallelism");

        }

 

        // start buffering incoming events so that we can re-route existing events

        for (Edge edge : sourceVertices.values()) {

          edge.startEventBuffering();

        }

 

        // Use a set since the same event may have been sent to multiple tasks

        // and we want to avoid duplicates

        Set<TezEvent> pendingEvents = new HashSet<TezEvent>();

 

        LOG.info("Vertex " + getVertexId() +

            " parallelism set to " + parallelism + " from " + numTasks);

        // assign to local variable of LinkedHashMap to make sure that changing

        // type of task causes compile error. We depend on LinkedHashMap for order

        LinkedHashMap<TezTaskID, Task> currentTasks = this.tasks;

        Iterator<Map.Entry<TezTaskID, Task>> iter = currentTasks.entrySet()

            .iterator();

        int i = 0;

        while (iter.hasNext()) {

          i++;

          Map.Entry<TezTaskID, Task> entry = iter.next();

          Task task = entry.getValue();

          if (task.getState() != TaskState.NEW) {

            LOG.warn(

                "All tasks must be in initial state when changing parallelism"

                    + " for vertex: " + getVertexId() + " name: " + getName());

            return false;

          }

          pendingEvents.addAll(task.getAndClearTaskTezEvents());

          if (i <= parallelism) {

            continue;

          }

          LOG.info("Removing task: " + entry.getKey());

          iter.remove();

        }

        this.numTasks = parallelism;

        assert tasks.size() == numTasks;

 

        // set new edge managers

        if(sourceEdgeManagers != null) {

          for(Map.Entry<String, EdgeManagerDescriptor> entry : sourceEdgeManagers.entrySet()) {

            LOG.info("Replacing edge manager for source:"

                + entry.getKey() + " destination: " + getVertexId());

            Vertex sourceVertex = appContext.getCurrentDAG().getVertex(entry.getKey());

            Edge edge = sourceVertices.get(sourceVertex);

            EdgeProperty edgeProperty = edge.getEdgeProperty();

            try {

              edge.setCustomEdgeManager(entry.getValue());

            } catch (Exception e) {

              LOG.warn("Failed to initialize edge manager for edge"

                  + ", sourceVertexName=" + sourceVertex.getName()

                  + ", destinationVertexName=" + edge.getDestinationVertexName(),

                  e);

              return false;

            }

          }

        }

 

        // Re-route all existing TezEvents according to new routing table

        // At this point only events attributed to source task attempts can be

        // re-routed. e.g. DataMovement or InputFailed events.

        // This assumption is fine for now since these tasks haven't been started.

        // So they can only get events generated from source task attempts that

        // have already been started.

        DAG dag = getDAG();

        for(TezEvent event : pendingEvents) {

          TezVertexID sourceVertexId = event.getSourceInfo().getTaskAttemptID()

              .getTaskID().getVertexID();

          Vertex sourceVertex = dag.getVertex(sourceVertexId);

          Edge sourceEdge = sourceVertices.get(sourceVertex);

          sourceEdge.sendTezEventToDestinationTasks(event);

        }

 

        // stop buffering events

        for (Edge edge : sourceVertices.values()) {

          edge.stopEventBuffering();

        }

      }

     

      for (Map.Entry<Vertex, Edge> entry : targetVertices.entrySet()) {

        Edge edge = entry.getValue();

        if (edge.getEdgeProperty().getDataMovementType()

            == DataMovementType.ONE_TO_ONE) {

          // inform these target vertices that we have changed parallelism

          VertexEventOneToOneSourceSplit event =

              new VertexEventOneToOneSourceSplit(entry.getKey().getVertexId(),

                  getVertexId(),

                  ((originalOneToOneSplitSource!=null) ?

                      originalOneToOneSplitSource : getVertexId()),

                  numTasks);

          getEventHandler().handle(event);

        }

      }

    } finally {

      writeLock.unlock();

    }

   

    return true;

  }

  public void setVertexLocationHint(VertexLocationHint vertexLocationHint) {

    writeLock.lock();

    try {

      this.vertexLocationHint = vertexLocationHint;

      if (LOG.isDebugEnabled()) {

        logLocationHints(this.vertexLocationHint);

      }

    } finally {

      writeLock.unlock();

    }

  }

  @Override

  /**

   * The only entry point to change the Vertex.

   */

  public void handle(VertexEvent event) {

    if (LOG.isDebugEnabled()) {

      LOG.debug("Processing VertexEvent " + event.getVertexId()

          + " of type " + event.getType() + " while in state "

          + getInternalState() + ". Event: " + event);

    }

    try {

      writeLock.lock();