Java Code Examples for org.apache.reef.util.Optional#of()

/**
 * Spawns a new context without services of its own.
 * <p>
 * The new context will have a serviceInjector that is created by forking the one in this object. The
 * contextConfiguration is used to fork the contextInjector from that new serviceInjector.
 *
 * @param contextConfiguration the new context's context (local) Configuration.
 * @return a child context.
 * @throws ContextClientCodeException If the context can't be instantiate due to user code / configuration issues.
 * @throws IllegalStateException      If this method is called when there is either a task or child context already
 *                                    present.
 */
ContextRuntime spawnChildContext(
    final Configuration contextConfiguration) throws ContextClientCodeException {

  synchronized (this.contextLifeCycle) {

    if (this.task.isPresent()) {
      throw new IllegalStateException(
          "Attempting to to spawn a child context while a Task with id '" +
              this.task.get().getId() + "' is running.");
    }

    if (this.childContext.isPresent()) {
      throw new IllegalStateException(
          "Attempting to spawn a child context on a context that is not the topmost active context");
    }

    final Injector childServiceInjector = this.serviceInjector.forkInjector();
    final ContextRuntime newChildContext =
        new ContextRuntime(childServiceInjector, contextConfiguration, Optional.of(this));

    this.childContext = Optional.of(newChildContext);
    return newChildContext;
  }
}
 

/**
 * Make configuration for evaluator.
 * @param contextConfiguration
 * @param serviceConfiguration
 * @param taskConfiguration
 * @return Configuration
 */
private Configuration makeEvaluatorConfiguration(final Configuration contextConfiguration,
                                                 final Optional<Configuration> serviceConfiguration,
                                                 final Optional<Configuration> taskConfiguration) {

  final String contextConfigurationString = this.configurationSerializer.toString(contextConfiguration);

  final Optional<String> taskConfigurationString;
  if (taskConfiguration.isPresent()) {
    taskConfigurationString = Optional.of(this.configurationSerializer.toString(taskConfiguration.get()));
  } else {
    taskConfigurationString = Optional.empty();
  }

  final Optional<Configuration> mergedServiceConfiguration = makeRootServiceConfiguration(serviceConfiguration);
  if (mergedServiceConfiguration.isPresent()) {
    final String serviceConfigurationString = this.configurationSerializer.toString(mergedServiceConfiguration.get());
    return makeEvaluatorConfiguration(contextConfigurationString, Optional.<String>empty(),
        Optional.of(serviceConfigurationString), taskConfigurationString);
  } else {
    return makeEvaluatorConfiguration(
        contextConfigurationString, Optional.<String>empty(), Optional.<String>empty(), taskConfigurationString);
  }
}
 

/**
 * @return a FailedContext for the case of an EvaluatorFailure.
 */
public synchronized FailedContext getFailedContextForEvaluatorFailure() {

  final String id = this.getId();
  final Optional<String> description = Optional.empty();
  final Optional<byte[]> data = Optional.empty();
  final Optional<Throwable> cause = Optional.empty();
  final String message = "Evaluator Failure";

  final Optional<ActiveContext> parentContext = getParentId().isPresent() ?
      Optional.<ActiveContext>of(this.contextRepresenters.getContext(getParentId().get())) :
      Optional.<ActiveContext>empty();

  final String evaluatorID = getEvaluatorId();

  return new FailedContextImpl(
      id, message, description, cause, data, parentContext, this.evaluatorDescriptor, evaluatorID);
}
 

private ActiveContextBridge toActiveContext(final ContextInfo contextInfo) {
  final AllocatedEvaluatorBridge eval = this.evaluatorBridgeMap.get(contextInfo.getEvaluatorId());
  return new ActiveContextBridge(
      this.driverServiceClient,
      contextInfo.getContextId(),
      StringUtils.isNotEmpty(contextInfo.getParentId()) ?
          Optional.of(contextInfo.getParentId()) : Optional.<String>empty(),
      eval.getId(),
      eval.getEvaluatorDescriptor());
}
 

@Override
public void onNext(final DriverMessage driverMessage) {
  final byte[] msg = driverMessage.get().get();
  LOG.log(Level.INFO, "NoopTask.DriverMessageHandler.send() invoked: {0}", CODEC.decode(msg));
  synchronized (NoopTask.this) {
    NoopTask.this.message = Optional.of(TaskMessage.from(NoopTask.this.toString(), msg));
  }
}
 

/**
 * Add aggregate-able Tasklets to pendingTasklets.
 */
@Override
public <TInput, TOutput> VortexAggregateFuture<TInput, TOutput>
    enqueueTasklets(final VortexAggregateFunction<TOutput> aggregateFunction,
                    final VortexFunction<TInput, TOutput> vortexFunction,
                    final VortexAggregatePolicy policy,
                    final List<TInput> inputs,
                    final Optional<FutureCallback<AggregateResult<TInput, TOutput>>> callback) {
  final int aggregateFunctionId = aggregateIdCounter.getAndIncrement();
  aggregateFunctionRepository.put(aggregateFunctionId, aggregateFunction, policy);
  final List<Tasklet> tasklets = new ArrayList<>(inputs.size());
  final Map<Integer, TInput> taskletIdInputMap = new HashMap<>(inputs.size());

  for (final TInput input : inputs) {
    taskletIdInputMap.put(taskletIdCounter.getAndIncrement(), input);
  }

  final VortexAggregateFuture<TInput, TOutput> vortexAggregateFuture;
  if (callback.isPresent()) {
    vortexAggregateFuture = new VortexAggregateFuture<>(executor, taskletIdInputMap, callback.get());
  } else {
    vortexAggregateFuture = new VortexAggregateFuture<>(executor, taskletIdInputMap, null);
  }

  for (final Map.Entry<Integer, TInput> taskletIdInputEntry : taskletIdInputMap.entrySet()) {
    final Tasklet tasklet = new Tasklet<>(taskletIdInputEntry.getKey(), Optional.of(aggregateFunctionId),
        vortexFunction, taskletIdInputEntry.getValue(), vortexAggregateFuture);
    tasklets.add(tasklet);
    pendingTasklets.addLast(tasklet);
  }

  putDelegate(tasklets, vortexAggregateFuture);
  return vortexAggregateFuture;
}
 

@Override
public Tuple<MockFailedContext, FailedTask> getFailureEvent() {
  return new Tuple<>(
      new MockFailedContext(this.context),
      new FailedTask(
          this.task.getId(),
          "mock",
          Optional.<String>empty(),
          Optional.<Throwable>empty(),
          Optional.<byte[]>empty(),
          Optional.of((ActiveContext)this.context)));
}
 

void setException(final Throwable throwable) {
  synchronized (this.heartBeatManager) {
    this.lastException = Optional.of(throwable);
    this.state = State.FAILED;
    this.check();
    this.heartbeat();
  }
}
 

/**
 * Checking from nextIndex, choose the first worker that fits to schedule the tasklet onto.
 * @param tasklet to schedule
 * @return the next worker that has enough resources for the tasklet
 */
@Override
public Optional<String> trySchedule(final Tasklet tasklet) {
  for (int i = 0; i < idList.size(); i++) {
    final int index = (nextIndex + i) % idList.size();
    final String workerId = idList.get(index);
    
    if (idLoadMap.get(workerId) < workerCapacity) {
      nextIndex = (index + 1) % idList.size();
      return Optional.of(workerId);
    }
  }
  return Optional.empty();
}
 

@Override
public FailedTask getFailureEvent() {
  return new FailedTask(
      this.task.getId(),
      "mock",
      Optional.<String>empty(),
      Optional.<Throwable>empty(),
      Optional.<byte[]>empty(),
      Optional.of(this.task.getActiveContext()));
}
 

@Override
public FailedTask getFailureEvent() {
  return new FailedTask(
    task.getId(),
    "mock",
    Optional.<String>empty(),
    Optional.<Throwable>empty(),
    Optional.<byte[]>empty(),
    Optional.of(this.task.getActiveContext()));
}
 

@Override
public void onNext(final RunningJob job) {
  LOG.log(Level.INFO, "The Job {0} is running", job.getId());
  synchronized (DriverMessaging.this) {
    DriverMessaging.this.status = LauncherStatus.RUNNING;
    DriverMessaging.this.theJob = Optional.of(job);
    DriverMessaging.this.lastMessage = "Hello, REEF!";
    DriverMessaging.this.theJob.get().send(DriverMessaging.this.lastMessage.getBytes(StandardCharsets.UTF_8));
  }
}
 

/**
 * @return the path to "JAVA_HOME", if that is set. Optional.empty(), else.
 */
private static Optional<Path> getJavaHome() {
  final Optional<String> javaHome = getEnv("JAVA_HOME");

  if (javaHome.isPresent()) {
    final File javaHomeFile = new File(javaHome.get());
    if (javaHomeFile.exists()) {
      return Optional.of(javaHomeFile.toPath());
    }
  }
  return Optional.empty();
}
 

@Override
public FailedTask getFailureEvent() {
  return new FailedTask(
      this.task.getId(),
      "mock",
      Optional.<String>empty(),
      Optional.<Throwable>empty(),
      Optional.<byte[]>empty(),
      Optional.of(this.task.getActiveContext()));
}
 

@Override
public Optional<TaskMessage> getMessage() {
  return Optional.of(taskMessage);
}
 

/**
 * Spawns a new context.
 * <p>
 * The new context will have a serviceInjector that is created by forking the one in this object with the given
 * serviceConfiguration. The contextConfiguration is used to fork the contextInjector from that new serviceInjector.
 *
 * @param contextConfiguration the new context's context (local) Configuration.
 * @param serviceConfiguration the new context's service Configuration.
 * @return a child context.
 * @throws ContextClientCodeException If the context can't be instantiate due to user code / configuration issues
 * @throws IllegalStateException      If this method is called when there is either a task or child context already
 *                                    present.
 */
ContextRuntime spawnChildContext(
    final Configuration contextConfiguration,
    final Configuration serviceConfiguration) throws ContextClientCodeException {

  synchronized (this.contextLifeCycle) {

    if (this.task.isPresent()) {
      throw new IllegalStateException(
          "Attempting to spawn a child context when a Task with id '" +
              this.task.get().getId() + "' is running.");
    }

    if (this.childContext.isPresent()) {
      throw new IllegalStateException(
          "Attempting to instantiate a child context on a context that is not the topmost active context");
    }

    try {

      final Injector childServiceInjector =
          this.serviceInjector.forkInjector(serviceConfiguration);

      final ContextRuntime newChildContext =
          new ContextRuntime(childServiceInjector, contextConfiguration, Optional.of(this));

      this.childContext = Optional.of(newChildContext);
      return newChildContext;

    } catch (final BindException e) {

      final Optional<String> parentID = this.getParentContext().isPresent() ?
          Optional.of(this.getParentContext().get().getIdentifier()) :
          Optional.<String>empty();

      throw new ContextClientCodeException(
          ContextClientCodeException.getIdentifier(contextConfiguration),
          parentID, "Unable to spawn context", e);
    }
  }
}
 

@Override
public Optional<String> getParentId() {
  return Optional.of(parentContext.getId());
}
 

@Override
public CLRLaunchCommandBuilder setConfigurationFilePaths(final List<String> configurationFilePaths) {
  this.evaluatorConfigurationPaths = Optional.of(configurationFilePaths);
  return this;
}
 

AggregateResult(final TOutput aggregatedOutput,
                final List<TInput> inputList) {
  this(Optional.of(aggregatedOutput), Optional.<Exception>empty(), inputList);
}
 

@Override
public Optional<String> getDescription() {
  return Optional.of(message);
}