<code>optional .alluxio.grpc.job.RegisterJobWorkerPOptions options = 2;</code>
492384
public alluxio.grpc.RegisterJobWorkerPOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.RegisterJobWorkerPOptions.getDefaultInstance() : options_;
  }
1347701
public alluxio.grpc.ListAllPOptions getOptions() {
    return options_ == null ? alluxio.grpc.ListAllPOptions.getDefaultInstance() : options_;
  }
1182491
public alluxio.grpc.GetUfsInfoPOptions getOptions() {
    return options_ == null ? alluxio.grpc.GetUfsInfoPOptions.getDefaultInstance() : options_;
  }
149243
@Override
  public void addJob(final Job job) throws JobExistsException {
    log.info("adding job: {}", job);
    final JobId id = job.getId();
    final UUID operationId = UUID.randomUUID();
    final String creationPath = Paths.configJobCreation(id, operationId);
    final ZooKeeperClient client = provider.get("addJob");
    try {
      try {
        client.ensurePath(Paths.historyJob(id));
        client.transaction(create(Paths.configJob(id), job),
            create(Paths.configJobRefShort(id), id),
            create(Paths.configJobHosts(id)),
            create(creationPath),
            // Touch the jobs root node so that its version is bumped on every job
            // change down the tree. Effectively, make it that version == cVersion.
            set(Paths.configJobs(), UUID.randomUUID().toString().getBytes()));
      } catch (final NodeExistsException e) {
        if (client.exists(creationPath) != null) {
          // The job was created, we're done here
          return;
        }
        throw new JobExistsException(id.toString());
      }
    } catch (NoNodeException e) {
      throw new HeliosRuntimeException("adding job " + job + " failed due to missing ZK path: "
                                       + e.getPath(), e);
    } catch (final KeeperException e) {
      throw new HeliosRuntimeException("adding job " + job + " failed", e);
    }
  }
910736
public alluxio.grpc.JobHeartbeatPOptions getOptions() {
    return options_ == null ? alluxio.grpc.JobHeartbeatPOptions.getDefaultInstance() : options_;
  }
208005
@SuppressWarnings("static-access")
  private static Options buildGeneralOptions(Options opts) {
    Option fs = OptionBuilder.withArgName("local|namenode:port")
    .hasArg()
    .withDescription("specify a namenode")
    .create("fs");
    Option jt = OptionBuilder.withArgName("local|jobtracker:port")
    .hasArg()
    .withDescription("specify a job tracker")
    .create("jt");
    Option oconf = OptionBuilder.withArgName("configuration file")
    .hasArg()
    .withDescription("specify an application configuration file")
    .create("conf");
    Option property = OptionBuilder.withArgName("property=value")
    .hasArg()
    .withDescription("use value for given property")
    .create('D');
    Option libjars = OptionBuilder.withArgName("paths")
    .hasArg()
    .withDescription("comma separated jar files to include in the classpath.")
    .create("libjars");
    Option files = OptionBuilder.withArgName("paths")
    .hasArg()
    .withDescription("comma separated files to be copied to the " +
           "map reduce cluster")
    .create("files");
    Option archives = OptionBuilder.withArgName("paths")
    .hasArg()
    .withDescription("comma separated archives to be unarchived" +
                     " on the compute machines.")
    .create("archives");

    opts.addOption(fs);
    opts.addOption(jt);
    opts.addOption(oconf);
    opts.addOption(property);
    opts.addOption(libjars);
    opts.addOption(files);
    opts.addOption(archives);

    return opts;
  }
929893
static RolloutOptions rolloutOptionsWithFallback(final RolloutOptions options, final Job job) {
    return options.withFallback(
        job.getRolloutOptions() == null
        ? RolloutOptions.getDefault()
        : job.getRolloutOptions().withFallback(RolloutOptions.getDefault()));
  }
542333
public alluxio.grpc.GetStatusPOptions getOptions() {
    return options_ == null ? alluxio.grpc.GetStatusPOptions.getDefaultInstance() : options_;
  }
1108528
public alluxio.grpc.UpdateUfsModePOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.UpdateUfsModePOptions.getDefaultInstance() : options_;
  }
416116
public void setJobType(int jobType) {
	String type = null;
	switch(jobType) {
	case JOBTYPE_SINGLE:
	    type = "single"; break;
	case JOBTYPE_MULTIPLE:
	    type = "multiple"; break;
	case JOBTYPE_MPI:
	    type = "mpi"; break;
	case JOBTYPE_CONDOR:
	    type = "condor"; break;
	}
	if (type != null) {
	    set("jobtype", type);
	}
    }
379407
@Override
	public List<BatchPartitionWorkUnit> buildOnRestartParallelPartitions(PartitionsBuilderConfig config) throws JobRestartException, JobExecutionAlreadyCompleteException, JobExecutionNotMostRecentException {

		List<JSLJob> jobModels = config.getJobModels();
		Properties[] partitionProperties = config.getPartitionProperties();

		List<BatchPartitionWorkUnit> batchWorkUnits = new ArrayList<BatchPartitionWorkUnit>(jobModels.size());

		//for now let always use a Properties array. We can add some more convenience methods later for null properties and what not

		int instance = 0;
		for (JSLJob parallelJob  : jobModels){

			Properties partitionProps = (partitionProperties == null) ? null : partitionProperties[instance];    

			try {
				long execId = getMostRecentSubJobExecutionId(parallelJob);

				RuntimeJobExecution jobExecution = null;
				try {		
					jobExecution = JobExecutionHelper.restartPartition(execId, parallelJob, partitionProps);
					jobExecution.setPartitionInstance(instance);
				} catch (NoSuchJobExecutionException e) {
					String errorMsg = "Caught NoSuchJobExecutionException but this is an internal JobExecution so this shouldn't have happened: execId =" + execId;
					logger.severe(errorMsg);
					throw new IllegalStateException(errorMsg, e);
				}

				if (logger.isLoggable(Level.FINE)) {
					logger.fine("JobExecution constructed: " + jobExecution);
				}

				BatchPartitionWorkUnit batchWork = new BatchPartitionWorkUnit(this, jobExecution, config);
				registerCurrentInstanceAndExecution(jobExecution, batchWork.getController());

				batchWorkUnits.add(batchWork);
			} catch (JobExecutionAlreadyCompleteException e) {
				logger.fine("This execution already completed: " + parallelJob.getId());
			}

			instance++;
		}

		return batchWorkUnits;
	}
745402
public alluxio.grpc.FreePOptions getOptions() {
    return options_ == null ? alluxio.grpc.FreePOptions.getDefaultInstance() : options_;
  }
12675
public static void printJob(Optional<JobExecutionInfo> jobExecutionInfoOptional) {
        if (!jobExecutionInfoOptional.isPresent()) {
            System.err.println("Job id not found.");
            return;
        }

        JobExecutionInfo jobExecutionInfo = jobExecutionInfoOptional.get();
        List<List<String>> data = new ArrayList<>();
        List<String> flags = Arrays.asList("", "-");

        data.add(Arrays.asList("Job Name", jobExecutionInfo.getJobName()));
        data.add(Arrays.asList("Job Id", jobExecutionInfo.getJobId()));
        data.add(Arrays.asList("State", jobExecutionInfo.getState().toString()));
        data.add(Arrays.asList("Completed/Launched Tasks",
                String.format("%d/%d", jobExecutionInfo.getCompletedTasks(), jobExecutionInfo.getLaunchedTasks())));
        data.add(Arrays.asList("Start Time", dateTimeFormatter.print(jobExecutionInfo.getStartTime())));
        data.add(Arrays.asList("End Time", dateTimeFormatter.print(jobExecutionInfo.getEndTime())));
        data.add(Arrays.asList("Duration", jobExecutionInfo.getState() == JobStateEnum.COMMITTED ? periodFormatter
                .print(new Period(jobExecutionInfo.getDuration().longValue())) : "-"));
        data.add(Arrays.asList("Tracking URL", jobExecutionInfo.getTrackingUrl()));
        data.add(Arrays.asList("Launcher Type", jobExecutionInfo.getLauncherType().name()));

        new CliTablePrinter.Builder()
                .data(data)
                .flags(flags)
                .delimiterWidth(2)
                .build()
                .printTable();

        JobInfoPrintUtils.printMetrics(jobExecutionInfo.getMetrics());
    }
420140
public alluxio.grpc.MountPOptions getOptions() {
    return options_ == null ? alluxio.grpc.MountPOptions.getDefaultInstance() : options_;
  }
14940
public Observable<Page<CloudJob>> listAsync(final JobListOptions jobListOptions) {
        return listWithServiceResponseAsync(jobListOptions)
            .map(new Func1<ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders>, Page<CloudJob>>() {
                @Override
                public Page<CloudJob> call(ServiceResponseWithHeaders<Page<CloudJob>, JobListHeaders> response) {
                    return response.body();
                }
            });
    }
1042808
public alluxio.grpc.MasterHeartbeatPOptionsOrBuilder getOptionsOrBuilder() {
    return options_ == null ? alluxio.grpc.MasterHeartbeatPOptions.getDefaultInstance() : options_;
  }
309010
public alluxio.grpc.CommitBlockPOptions getOptions() {
    return options_ == null ? alluxio.grpc.CommitBlockPOptions.getDefaultInstance() : options_;
  }