com.hubspot.singularity.SingularityRequestBuilder 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 static com.google.common.base.Preconditions.checkNotNull;

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

import com.google.common.base.Optional;

public class SingularityRequestBuilder {

  private final String id;
  private final RequestType requestType;

  private Optional> owners;
  private Optional numRetriesOnFailure;

  private Optional schedule;
  private Optional quartzSchedule;
  private Optional scheduleType;

  private Optional killOldNonLongRunningTasksAfterMillis;
  private Optional scheduledExpectedRuntimeMillis;

  private Optional waitAtLeastMillisAfterTaskFinishesForReschedule;

  private Optional instances;
  private Optional skipHealthchecks;

  private Optional rackSensitive;
  private Optional> rackAffinity;
  private Optional slavePlacement;
  private Optional> requiredSlaveAttributes;
  private Optional> allowedSlaveAttributes;

  private Optional loadBalanced;

  private Optional group;
  private Optional> readOnlyGroups;
  private Optional bounceAfterScale;
  private Optional>> emailConfigurationOverrides;
  private Optional hideEvenNumberAcrossRacksHint;
  private Optional taskLogErrorRegex;
  private Optional taskLogErrorRegexCaseSensitive;

  public SingularityRequestBuilder(String id, RequestType requestType) {
    this.id = checkNotNull(id, "id cannot be null");
    this.requestType = checkNotNull(requestType, "requestType cannot be null");
    this.owners = Optional.absent();
    this.numRetriesOnFailure = Optional.absent();
    this.schedule = Optional.absent();
    this.scheduleType = Optional.absent();
    this.killOldNonLongRunningTasksAfterMillis = Optional.absent();
    this.instances = Optional.absent();
    this.rackSensitive = Optional.absent();
    this.loadBalanced = Optional.absent();
    this.quartzSchedule = Optional.absent();
    this.rackAffinity = Optional.absent();
    this.slavePlacement = Optional.absent();
    this.requiredSlaveAttributes = Optional.absent();
    this.allowedSlaveAttributes = Optional.absent();
    this.scheduledExpectedRuntimeMillis = Optional.absent();
    this.waitAtLeastMillisAfterTaskFinishesForReschedule = Optional.absent();
    this.group = Optional.absent();
    this.readOnlyGroups = Optional.absent();
    this.bounceAfterScale = Optional.absent();
    this.emailConfigurationOverrides = Optional.absent();
    this.skipHealthchecks = Optional.absent();
    this.hideEvenNumberAcrossRacksHint = Optional.absent();
    this.taskLogErrorRegex = Optional.absent();
    this.taskLogErrorRegexCaseSensitive = Optional.absent();
  }

  public SingularityRequest build() {
    return new SingularityRequest(id, requestType, owners, numRetriesOnFailure, schedule, instances, rackSensitive, loadBalanced, killOldNonLongRunningTasksAfterMillis, scheduleType, quartzSchedule,
        rackAffinity, slavePlacement, requiredSlaveAttributes, allowedSlaveAttributes, scheduledExpectedRuntimeMillis, waitAtLeastMillisAfterTaskFinishesForReschedule, group, readOnlyGroups,
        bounceAfterScale, skipHealthchecks, emailConfigurationOverrides, Optional.absent(), hideEvenNumberAcrossRacksHint, taskLogErrorRegex, taskLogErrorRegexCaseSensitive);
  }

  public Optional getSkipHealthchecks() {
    return skipHealthchecks;
  }

  public SingularityRequestBuilder setSkipHealthchecks(Optional skipHealthchecks) {
    this.skipHealthchecks = skipHealthchecks;
    return this;
  }

  public Optional getLoadBalanced() {
    return loadBalanced;
  }

  public SingularityRequestBuilder setLoadBalanced(Optional loadBalanced) {
    this.loadBalanced = loadBalanced;
    return this;
  }

  public String getId() {
    return id;
  }

  public Optional> getOwners() {
    return owners;
  }

  public SingularityRequestBuilder setOwners(Optional> owners) {
    this.owners = owners;
    return this;
  }

  public Optional getNumRetriesOnFailure() {
    return numRetriesOnFailure;
  }

  public SingularityRequestBuilder setNumRetriesOnFailure(Optional numRetriesOnFailure) {
    this.numRetriesOnFailure = numRetriesOnFailure;
    return this;
  }

  public Optional getSchedule() {
    return schedule;
  }

  public SingularityRequestBuilder setSchedule(Optional schedule) {
    this.schedule = schedule;
    return this;
  }

  public Optional getInstances() {
    return instances;
  }

  public SingularityRequestBuilder setInstances(Optional instances) {
    this.instances = instances;
    return this;
  }

  public Optional getRackSensitive() {
    return rackSensitive;
  }

  public SingularityRequestBuilder setRackSensitive(Optional rackSensitive) {
    this.rackSensitive = rackSensitive;
    return this;
  }

  public Optional getKillOldNonLongRunningTasksAfterMillis() {
    return killOldNonLongRunningTasksAfterMillis;
  }

  public SingularityRequestBuilder setKillOldNonLongRunningTasksAfterMillis(Optional killOldNonLongRunningTasksAfterMillis) {
    this.killOldNonLongRunningTasksAfterMillis = killOldNonLongRunningTasksAfterMillis;
    return this;
  }

  public Optional getScheduleType() {
    return scheduleType;
  }

  public SingularityRequestBuilder setScheduleType(Optional scheduleType) {
    this.scheduleType = scheduleType;
    return this;
  }

  public Optional getQuartzSchedule() {
    return quartzSchedule;
  }

  public SingularityRequestBuilder setQuartzSchedule(Optional quartzSchedule) {
    this.quartzSchedule = quartzSchedule;
    return this;
  }

  public Optional> getRackAffinity() {
    return rackAffinity;
  }

  public SingularityRequestBuilder setRackAffinity(Optional> rackAffinity) {
    this.rackAffinity = rackAffinity;
    return this;
  }

  public Optional getSlavePlacement() {
    return slavePlacement;
  }

  public SingularityRequestBuilder setSlavePlacement(Optional slavePlacement) {
    this.slavePlacement = slavePlacement;
    return this;
  }

  public Optional getScheduledExpectedRuntimeMillis() {
    return scheduledExpectedRuntimeMillis;
  }

  public SingularityRequestBuilder setScheduledExpectedRuntimeMillis(Optional scheduledExpectedRuntimeMillis) {
    this.scheduledExpectedRuntimeMillis = scheduledExpectedRuntimeMillis;
    return this;
  }

  public RequestType getRequestType() {
    return requestType;
  }

  public Optional getWaitAtLeastMillisAfterTaskFinishesForReschedule() {
    return waitAtLeastMillisAfterTaskFinishesForReschedule;
  }

  public SingularityRequestBuilder setWaitAtLeastMillisAfterTaskFinishesForReschedule(Optional waitAtLeastMillisAfterTaskFinishesForReschedule) {
    this.waitAtLeastMillisAfterTaskFinishesForReschedule = waitAtLeastMillisAfterTaskFinishesForReschedule;
    return this;
  }

  public Optional getGroup() {
    return group;
  }

  public SingularityRequestBuilder setGroup(Optional group) {
    this.group = group;
    return this;
  }

  public SingularityRequestBuilder setRequiredSlaveAttributes(Optional> requiredSlaveAttributes) {
    this.requiredSlaveAttributes = requiredSlaveAttributes;
    return this;
  }

  public SingularityRequestBuilder setAllowedSlaveAttributes(Optional> allowedSlaveAttributes) {
    this.allowedSlaveAttributes = allowedSlaveAttributes;
    return this;
  }

  public Optional> getReadOnlyGroups() {
    return readOnlyGroups;
  }

  public SingularityRequestBuilder setReadOnlyGroups(Optional> readOnlyGroups) {
    this.readOnlyGroups = readOnlyGroups;
    return this;
  }

  public Optional getBounceAfterScale() {
    return bounceAfterScale;
  }

  public SingularityRequestBuilder setBounceAfterScale(Optional bounceAfterScale) {
    this.bounceAfterScale = bounceAfterScale;
    return this;
  }

  public Optional>> getEmailConfigurationOverrides() {
    return emailConfigurationOverrides;
  }

  public SingularityRequestBuilder setEmailConfigurationOverrides(Optional>> emailConfigurationOverrides) {
    this.emailConfigurationOverrides = emailConfigurationOverrides;
    return this;
  }

  public Optional getHideEvenNumberAcrossRacksHint() { return hideEvenNumberAcrossRacksHint; }

  public SingularityRequestBuilder setHideEvenNumberAcrossRacksHint(Optional hideEvenNumberAcrossRacksHint) {
    this.hideEvenNumberAcrossRacksHint = hideEvenNumberAcrossRacksHint;
    return this;
  }

  public Optional getTaskLogErrorRegex() { return taskLogErrorRegex; }

  public SingularityRequestBuilder setTaskLogErrorRegex(Optional taskLogErrorRegex) {
    this.taskLogErrorRegex = taskLogErrorRegex;
    return this;
  }

  public Optional getTaskLogErrorRegexCaseSensitive() { return taskLogErrorRegexCaseSensitive; }

  public SingularityRequestBuilder setTaskLogErrorRegexCaseSensitive(Optional taskLogErrorRegexCaseSensitive) {
    this.taskLogErrorRegexCaseSensitive = taskLogErrorRegexCaseSensitive;
    return this;
  }

  @Override
  public String toString() {
    return "SingularityRequestBuilder[" +
            "id='" + id + '\'' +
            ", requestType=" + requestType +
            ", owners=" + owners +
            ", numRetriesOnFailure=" + numRetriesOnFailure +
            ", schedule=" + schedule +
            ", quartzSchedule=" + quartzSchedule +
            ", scheduleType=" + scheduleType +
            ", killOldNonLongRunningTasksAfterMillis=" + killOldNonLongRunningTasksAfterMillis +
            ", scheduledExpectedRuntimeMillis=" + scheduledExpectedRuntimeMillis +
            ", waitAtLeastMillisAfterTaskFinishesForReschedule=" + waitAtLeastMillisAfterTaskFinishesForReschedule +
            ", instances=" + instances +
            ", rackSensitive=" + rackSensitive +
            ", rackAffinity=" + rackAffinity +
            ", slavePlacement=" + slavePlacement +
            ", requiredSlaveAttrbiutes=" + requiredSlaveAttributes +
            ", allowedSlaveAttrbiutes=" + allowedSlaveAttributes +
            ", loadBalanced=" + loadBalanced +
            ", group=" + group +
            ", readOnlyGroups=" + readOnlyGroups +
            ", bounceAfterScale=" + bounceAfterScale +
            ", emailConfigurationOverrides=" + emailConfigurationOverrides +
            ", skipHealthchecks=" + skipHealthchecks +
            ", hideEvenNumberAcrossRacksHint=" + hideEvenNumberAcrossRacksHint +
            ", taskLogErrorRegex=" + taskLogErrorRegex +
            ", taskLogErrorRegexCaseSensitive=" + taskLogErrorRegexCaseSensitive +
            ']';
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    SingularityRequestBuilder that = (SingularityRequestBuilder) o;
    return Objects.equals(id, that.id) &&
            Objects.equals(requestType, that.requestType) &&
            Objects.equals(owners, that.owners) &&
            Objects.equals(numRetriesOnFailure, that.numRetriesOnFailure) &&
            Objects.equals(schedule, that.schedule) &&
            Objects.equals(quartzSchedule, that.quartzSchedule) &&
            Objects.equals(scheduleType, that.scheduleType) &&
            Objects.equals(killOldNonLongRunningTasksAfterMillis, that.killOldNonLongRunningTasksAfterMillis) &&
            Objects.equals(scheduledExpectedRuntimeMillis, that.scheduledExpectedRuntimeMillis) &&
            Objects.equals(waitAtLeastMillisAfterTaskFinishesForReschedule, that.waitAtLeastMillisAfterTaskFinishesForReschedule) &&
            Objects.equals(instances, that.instances) &&
            Objects.equals(rackSensitive, that.rackSensitive) &&
            Objects.equals(rackAffinity, that.rackAffinity) &&
            Objects.equals(slavePlacement, that.slavePlacement) &&
            Objects.equals(requiredSlaveAttributes, that.requiredSlaveAttributes) &&
            Objects.equals(allowedSlaveAttributes, that.allowedSlaveAttributes) &&
            Objects.equals(loadBalanced, that.loadBalanced) &&
            Objects.equals(group, that.group) &&
            Objects.equals(readOnlyGroups, that.readOnlyGroups) &&
            Objects.equals(bounceAfterScale, that.bounceAfterScale) &&
            Objects.equals(skipHealthchecks, that.skipHealthchecks) &&
            Objects.equals(emailConfigurationOverrides, that.emailConfigurationOverrides) &&
            Objects.equals(hideEvenNumberAcrossRacksHint, that.hideEvenNumberAcrossRacksHint) &&
            Objects.equals(taskLogErrorRegex, that.taskLogErrorRegex) &&
            Objects.equals(taskLogErrorRegexCaseSensitive, that.taskLogErrorRegexCaseSensitive);
  }

  @Override
  public int hashCode() {
    return Objects.hash(id, requestType, owners, numRetriesOnFailure, schedule, quartzSchedule, scheduleType, killOldNonLongRunningTasksAfterMillis,
        scheduledExpectedRuntimeMillis, waitAtLeastMillisAfterTaskFinishesForReschedule, instances, rackSensitive, rackAffinity, slavePlacement,
        requiredSlaveAttributes, allowedSlaveAttributes, loadBalanced, group, readOnlyGroups, bounceAfterScale, skipHealthchecks, emailConfigurationOverrides,
        hideEvenNumberAcrossRacksHint, taskLogErrorRegex, taskLogErrorRegexCaseSensitive);
  }

}