com.hubspot.singularity.SingularityDeployBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of SingularityBase Show documentation
The newest version!
package com.hubspot.singularity;

import java.util.List;
import java.util.Map;
import java.util.Set;

import com.google.common.base.Optional;
import com.hubspot.deploy.ExecutorData;
import com.hubspot.mesos.Resources;
import com.hubspot.mesos.SingularityContainerInfo;

public class SingularityDeployBuilder {

  private final String requestId;

  private String id;

  private Optional version;
  private Optional timestamp;
  private Optional> metadata;

  private Optional containerInfo;

  private Optional customExecutorCmd;
  private Optional customExecutorId;
  private Optional customExecutorSource;
  private Optional customExecutorResources;
  private Optional customExecutorUser;

  private Optional resources;

  private Optional command;
  private Optional> arguments;
  private Optional> env;
  private Optional>> taskEnv;
  private Optional> uris;
  private Optional executorData;
  private Optional> labels;
  private Optional>> taskLabels;

  private Optional healthcheckUri;
  private Optional healthcheckIntervalSeconds;
  private Optional healthcheckTimeoutSeconds;
  private Optional healthcheckPortIndex;
  private Optional skipHealthchecksOnDeploy;
  private Optional healthcheckProtocol;

  private Optional healthcheckMaxRetries;
  private Optional healthcheckMaxTotalTimeoutSeconds;

  private Optional deployHealthTimeoutSeconds;

  private Optional considerHealthyAfterRunningForSeconds;

  private Optional serviceBasePath;
  private Optional> loadBalancerGroups;
  private Optional loadBalancerPortIndex;
  private Optional> loadBalancerOptions;
  private Optional> loadBalancerDomains;
  private Optional> loadBalancerAdditionalRoutes;
  private Optional loadBalancerTemplate;

  private Optional deployInstanceCountPerStep;
  private Optional deployStepWaitTimeMs;
  private Optional autoAdvanceDeploySteps;
  private Optional maxTaskRetries;
  private Optional shell;

  public SingularityDeployBuilder(String requestId, String id) {
    this.requestId = requestId;
    this.id = id;
    this.version = Optional.absent();
    this.timestamp = Optional.absent();
    this.metadata = Optional.absent();
    this.containerInfo = Optional.absent();
    this.customExecutorCmd = Optional.absent();
    this.customExecutorId = Optional.absent();
    this.customExecutorSource = Optional.absent();
    this.customExecutorResources = Optional.absent();
    this.customExecutorUser = Optional.absent();
    this.resources = Optional.absent();
    this.command = Optional.absent();
    this.arguments = Optional.absent();
    this.env = Optional.absent();
    this.taskEnv = Optional.absent();
    this.uris = Optional.absent();
    this.executorData = Optional.absent();
    this.labels = Optional.absent();
    this.taskLabels = Optional.absent();
    this.healthcheckUri = Optional.absent();
    this.healthcheckIntervalSeconds = Optional.absent();
    this.healthcheckTimeoutSeconds = Optional.absent();
    this.healthcheckPortIndex = Optional.absent();
    this.skipHealthchecksOnDeploy = Optional.absent();
    this.deployHealthTimeoutSeconds = Optional.absent();
    this.healthcheckProtocol = Optional.absent();
    this.healthcheckMaxTotalTimeoutSeconds = Optional.absent();
    this.healthcheckMaxRetries = Optional.absent();
    this.considerHealthyAfterRunningForSeconds = Optional.absent();
    this.serviceBasePath = Optional.absent();
    this.loadBalancerGroups = Optional.absent();
    this.loadBalancerPortIndex = Optional.absent();
    this.loadBalancerOptions = Optional.absent();
    this.loadBalancerDomains = Optional.absent();
    this.loadBalancerAdditionalRoutes = Optional.absent();
    this.loadBalancerTemplate = Optional.absent();
    this.deployInstanceCountPerStep = Optional.absent();
    this.deployStepWaitTimeMs = Optional.absent();
    this.autoAdvanceDeploySteps = Optional.absent();
    this.maxTaskRetries = Optional.absent();
    this.shell = Optional.absent();
  }

  public SingularityDeploy build() {
    return new SingularityDeploy(requestId, id, command, arguments, containerInfo, customExecutorCmd, customExecutorId, customExecutorSource, customExecutorResources, customExecutorUser, resources,
      env, taskEnv, uris, metadata, executorData, version, timestamp, labels, taskLabels, deployHealthTimeoutSeconds, healthcheckUri, healthcheckIntervalSeconds, healthcheckTimeoutSeconds, healthcheckPortIndex, healthcheckMaxRetries,
      healthcheckMaxTotalTimeoutSeconds, serviceBasePath, loadBalancerGroups, loadBalancerPortIndex, considerHealthyAfterRunningForSeconds, loadBalancerOptions, loadBalancerDomains, loadBalancerAdditionalRoutes,
      loadBalancerTemplate, skipHealthchecksOnDeploy, healthcheckProtocol, deployInstanceCountPerStep, deployStepWaitTimeMs, autoAdvanceDeploySteps, maxTaskRetries, shell);
  }

  public String getRequestId() {
    return requestId;
  }

  public String getId() {
    return id;
  }

  public SingularityDeployBuilder setId(String id) {
    this.id = id;
    return this;
  }

  public Optional getConsiderHealthyAfterRunningForSeconds() {
    return considerHealthyAfterRunningForSeconds;
  }

  public SingularityDeployBuilder setConsiderHealthyAfterRunningForSeconds(Optional considerHealthyAfterRunningForSeconds) {
    this.considerHealthyAfterRunningForSeconds = considerHealthyAfterRunningForSeconds;
    return this;
  }

  public Optional getVersion() {
    return version;
  }

  public SingularityDeployBuilder setVersion(Optional version) {
    this.version = version;
    return this;
  }

  public Optional getTimestamp() {
    return timestamp;
  }

  public SingularityDeployBuilder setTimestamp(Optional timestamp) {
    this.timestamp = timestamp;
    return this;
  }

  public Optional> getMetadata() {
    return metadata;
  }

  public SingularityDeployBuilder setMetadata(Optional> metadata) {
    this.metadata = metadata;
    return this;
  }

  public Optional getContainerInfo() {
    return containerInfo;
  }

  public SingularityDeployBuilder setContainerInfo(Optional containerInfo) {
    this.containerInfo = containerInfo;
    return this;
  }

  public Optional getCustomExecutorCmd() {
    return customExecutorCmd;
  }

  public SingularityDeployBuilder setCustomExecutorCmd(Optional customExecutorCmd) {
    this.customExecutorCmd = customExecutorCmd;
    return this;
  }

  public Optional getCustomExecutorId() {
    return customExecutorId;
  }

  public SingularityDeployBuilder setCustomExecutorId(Optional customExecutorId) {
    this.customExecutorId = customExecutorId;
    return this;
  }

  public Optional getCustomExecutorSource() {
    return customExecutorSource;
  }

  public SingularityDeployBuilder setCustomExecutorSource(Optional customExecutorSource) {
    this.customExecutorSource = customExecutorSource;
    return this;
  }

  public Optional getCustomExecutorResources() {
    return customExecutorResources;
  }

  public SingularityDeployBuilder setCustomExecutorResources(Optional customExecutorResources) {
    this.customExecutorResources = customExecutorResources;
    return this;
  }

  public Optional getCustomExecutorUser() {
    return customExecutorUser;
  }

  public SingularityDeployBuilder setCustomExecutorUser(Optional customExecutorUser) {
    this.customExecutorUser = customExecutorUser;
    return this;
  }

  public Optional getDeployHealthTimeoutSeconds() {
    return deployHealthTimeoutSeconds;
  }

  public SingularityDeployBuilder setDeployHealthTimeoutSeconds(Optional deployHealthTimeoutSeconds) {
    this.deployHealthTimeoutSeconds = deployHealthTimeoutSeconds;
    return this;
  }

  public Optional getResources() {
    return resources;
  }

  public SingularityDeployBuilder setResources(Optional resources) {
    this.resources = resources;
    return this;
  }

  public Optional getCommand() {
    return command;
  }

  public SingularityDeployBuilder setCommand(Optional command) {
    this.command = command;
    return this;
  }

  public Optional> getArguments() {
    return arguments;
  }

  public SingularityDeployBuilder setArguments(Optional> arguments) {
    this.arguments = arguments;
    return this;
  }

  public Optional> getEnv() {
    return env;
  }

  public SingularityDeployBuilder setEnv(Optional> env) {
    this.env = env;
    return this;
  }

  public Optional>> getTaskEnv() {
    return taskEnv;
  }

  public SingularityDeployBuilder setTaskEnv(Optional>> taskEnv) {
    this.taskEnv = taskEnv;
    return this;
  }

  public Optional> getUris() {
    return uris;
  }

  public SingularityDeployBuilder setUris(Optional> uris) {
    this.uris = uris;
    return this;
  }

  public Optional getExecutorData() {
    return executorData;
  }

  public SingularityDeployBuilder setExecutorData(Optional executorData) {
    this.executorData = executorData;
    return this;
  }

  public Optional getHealthcheckUri() {
    return healthcheckUri;
  }

  public SingularityDeployBuilder setHealthcheckUri(Optional healthcheckUri) {
    this.healthcheckUri = healthcheckUri;
    return this;
  }

  public Optional getHealthcheckIntervalSeconds() {
    return healthcheckIntervalSeconds;
  }

  public SingularityDeployBuilder setHealthcheckIntervalSeconds(Optional healthcheckIntervalSeconds) {
    this.healthcheckIntervalSeconds = healthcheckIntervalSeconds;
    return this;
  }

  public Optional getHealthcheckTimeoutSeconds() {
    return healthcheckTimeoutSeconds;
  }

  public SingularityDeployBuilder setHealthcheckTimeoutSeconds(Optional healthcheckTimeoutSeconds) {
    this.healthcheckTimeoutSeconds = healthcheckTimeoutSeconds;
    return this;
  }

  public Optional getHealthcheckPortIndex() {
    return healthcheckPortIndex;
  }

  public SingularityDeployBuilder setHealthcheckPortIndex(Optional healthcheckPortIndex) {
    this.healthcheckPortIndex = healthcheckPortIndex;
    return this;
  }

  public Optional getServiceBasePath() {
    return serviceBasePath;
  }

  public SingularityDeployBuilder setServiceBasePath(Optional serviceBasePath) {
    this.serviceBasePath = serviceBasePath;
    return this;
  }

  public Optional> getLoadBalancerGroups() {
    return loadBalancerGroups;
  }

  public SingularityDeployBuilder setLoadBalancerGroups(Optional> loadBalancerGroups) {
    this.loadBalancerGroups = loadBalancerGroups;
    return this;
  }

  public Optional getLoadBalancerPortIndex() {
    return loadBalancerPortIndex;
  }

  public SingularityDeployBuilder setLoadBalancerPortIndex(Optional loadBalancerPortIndex) {
    this.loadBalancerPortIndex = loadBalancerPortIndex;
    return this;
  }

  public Optional> getLoadBalancerOptions() {
    return loadBalancerOptions;
  }

  public SingularityDeployBuilder setLoadBalancerOptions(Optional> loadBalancerOptions) {
    this.loadBalancerOptions = loadBalancerOptions;
    return this;
  }

  public Optional> getLoadBalancerDomains() {
    return loadBalancerDomains;
  }

  public SingularityDeployBuilder setLoadBalancerDomains(Optional> loadBalancerDomains) {
    this.loadBalancerDomains = loadBalancerDomains;
    return this;
  }

  public Optional> getLoadBalancerAdditionalRoutes() {
    return loadBalancerAdditionalRoutes;
  }

  public SingularityDeployBuilder setLoadBalancerAdditionalRoutes(Optional> loadBalancerAdditionalRoutes) {
    this.loadBalancerAdditionalRoutes = loadBalancerAdditionalRoutes;
    return this;
  }

  public Optional getLoadBalancerTemplate() {
    return loadBalancerTemplate;
  }

  public SingularityDeployBuilder setLoadBalancerTemplate(Optional loadBalancerTemplate) {
    this.loadBalancerTemplate = loadBalancerTemplate;
    return this;
  }

  public Optional> getLabels() {
    return labels;
  }

  public SingularityDeployBuilder setLabels(Optional> labels) {
    this.labels = labels;
    return this;
  }

  public Optional>> getTaskLabels() {
    return taskLabels;
  }

  public SingularityDeployBuilder setTaskLabels(Optional>> taskLabels) {
    this.taskLabels = taskLabels;
    return this;
  }

  public Optional getSkipHealthchecksOnDeploy() {
    return skipHealthchecksOnDeploy;
  }

  public SingularityDeployBuilder setSkipHealthchecksOnDeploy(Optional skipHealthchecksOnDeploy) {
    this.skipHealthchecksOnDeploy = skipHealthchecksOnDeploy;
    return this;
  }

  public Optional getHealthcheckProtocol() {
    return healthcheckProtocol;
  }

  public SingularityDeployBuilder setHealthcheckProtocol(Optional healthcheckProtocol) {
    this.healthcheckProtocol = healthcheckProtocol;
    return this;
  }

  public Optional getHealthcheckMaxRetries() {
    return healthcheckMaxRetries;
  }

  public Optional getHealthcheckMaxTotalTimeoutSeconds() {
    return healthcheckMaxTotalTimeoutSeconds;
  }

  public SingularityDeployBuilder setHealthcheckMaxRetries(Optional healthcheckMaxRetries) {
    this.healthcheckMaxRetries = healthcheckMaxRetries;
    return this;
  }

  public SingularityDeployBuilder setHealthcheckMaxTotalTimeoutSeconds(Optional healthcheckMaxTotalTimeoutSeconds) {
    this.healthcheckMaxTotalTimeoutSeconds = healthcheckMaxTotalTimeoutSeconds;
    return this;
  }

  public Optional getDeployInstanceCountPerStep() {
    return deployInstanceCountPerStep;
  }

  public SingularityDeployBuilder setDeployInstanceCountPerStep(Optional deployInstanceCountPerStep) {
    this.deployInstanceCountPerStep = deployInstanceCountPerStep;
    return this;
  }

  public Optional getDeployStepWaitTimeMs() {
    return deployStepWaitTimeMs;
  }

  public SingularityDeployBuilder setDeployStepWaitTimeMs(Optional deployStepWaitTimeMs) {
    this.deployStepWaitTimeMs = deployStepWaitTimeMs;
    return this;
  }

  public Optional getAutoAdvanceDeploySteps() {
    return autoAdvanceDeploySteps;
  }

  public SingularityDeployBuilder setAutoAdvanceDeploySteps(Optional autoAdvanceDeploySteps) {
    this.autoAdvanceDeploySteps = autoAdvanceDeploySteps;
    return this;
  }

  public Optional getMaxTaskRetries() {
    return maxTaskRetries;
  }

  public SingularityDeployBuilder setMaxTaskRetries(Optional maxTaskRetries) {
    this.maxTaskRetries = maxTaskRetries;
    return this;
  }

  public Optional getShell() {
    return shell;
  }

  public SingularityDeployBuilder setShell(Optional shell) {
    this.shell = shell;
    return this;
  }

  @Override
  public String toString() {
    return "SingularityDeployBuilder{" +
      "requestId='" + requestId + '\'' +
      ", id='" + id + '\'' +
      ", version=" + version +
      ", timestamp=" + timestamp +
      ", metadata=" + metadata +
      ", containerInfo=" + containerInfo +
      ", customExecutorCmd=" + customExecutorCmd +
      ", customExecutorId=" + customExecutorId +
      ", customExecutorSource=" + customExecutorSource +
      ", customExecutorResources=" + customExecutorResources +
      ", customExecutorUser=" + customExecutorUser +
      ", resources=" + resources +
      ", command=" + command +
      ", arguments=" + arguments +
      ", env=" + env +
      ", taskEnv=" + taskEnv +
      ", uris=" + uris +
      ", executorData=" + executorData +
      ", labels=" + labels +
      ", taskLabels=" + taskLabels +
      ", healthcheckUri=" + healthcheckUri +
      ", healthcheckIntervalSeconds=" + healthcheckIntervalSeconds +
      ", healthcheckTimeoutSeconds=" + healthcheckTimeoutSeconds +
      ", healthcheckPortIndex=" + healthcheckPortIndex +
      ", skipHealthchecksOnDeploy=" + skipHealthchecksOnDeploy +
      ", healthcheckProtocol=" + healthcheckProtocol +
      ", healthcheckMaxRetries=" + healthcheckMaxRetries +
      ", healthcheckMaxTotalTimeoutSeconds=" + healthcheckMaxTotalTimeoutSeconds +
      ", deployHealthTimeoutSeconds=" + deployHealthTimeoutSeconds +
      ", considerHealthyAfterRunningForSeconds=" + considerHealthyAfterRunningForSeconds +
      ", serviceBasePath=" + serviceBasePath +
      ", loadBalancerGroups=" + loadBalancerGroups +
      ", loadBalancerPortIndex=" + loadBalancerPortIndex +
      ", loadBalancerOptions=" + loadBalancerOptions +
      ", loadBalancerDomains=" + loadBalancerDomains +
      ", loadBalancerAdditionalRoutes=" + loadBalancerAdditionalRoutes +
      ", loadBalancerTemplate=" + loadBalancerTemplate +
      ", deployInstanceCountPerStep=" + deployInstanceCountPerStep +
      ", deployStepWaitTimeMs=" + deployStepWaitTimeMs +
      ", autoAdvanceDeploySteps=" + autoAdvanceDeploySteps +
      ", maxTaskRetries=" + maxTaskRetries +
      '}';
  }

}