com.hubspot.singularity.SingularityRequest 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 static com.hubspot.singularity.JsonHelpers.copyOfList;

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

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.base.Optional;

public class SingularityRequest {

  private final String id;
  private final RequestType requestType;

  private final Optional> owners;
  private final Optional numRetriesOnFailure;

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

  private final Optional killOldNonLongRunningTasksAfterMillis;
  private final Optional scheduledExpectedRuntimeMillis;

  private final Optional waitAtLeastMillisAfterTaskFinishesForReschedule;

  private final Optional instances;
  private final Optional skipHealthchecks;

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

  private final Optional loadBalanced;

  private final Optional group;
  private final Optional> readOnlyGroups;
  private final Optional bounceAfterScale;

  private final Optional>> emailConfigurationOverrides;

  private final Optional hideEvenNumberAcrossRacksHint;

  private final Optional taskLogErrorRegex;
  private final Optional taskLogErrorRegexCaseSensitive;

  @JsonCreator
  public SingularityRequest(@JsonProperty("id") String id, @JsonProperty("requestType") RequestType requestType, @JsonProperty("owners") Optional> owners,
      @JsonProperty("numRetriesOnFailure") Optional numRetriesOnFailure, @JsonProperty("schedule") Optional schedule, @JsonProperty("instances") Optional instances,
      @JsonProperty("rackSensitive") Optional rackSensitive, @JsonProperty("loadBalanced") Optional loadBalanced,
      @JsonProperty("killOldNonLongRunningTasksAfterMillis") Optional killOldNonLongRunningTasksAfterMillis, @JsonProperty("scheduleType") Optional scheduleType,
      @JsonProperty("quartzSchedule") Optional quartzSchedule, @JsonProperty("rackAffinity") Optional> rackAffinity,
      @JsonProperty("slavePlacement") Optional slavePlacement, @JsonProperty("requiredSlaveAttributes") Optional> requiredSlaveAttributes,
      @JsonProperty("allowedSlaveAttributes") Optional> allowedSlaveAttributes, @JsonProperty("scheduledExpectedRuntimeMillis") Optional scheduledExpectedRuntimeMillis,
      @JsonProperty("waitAtLeastMillisAfterTaskFinishesForReschedule") Optional waitAtLeastMillisAfterTaskFinishesForReschedule, @JsonProperty("group") Optional group,
      @JsonProperty("readOnlyGroups") Optional> readOnlyGroups, @JsonProperty("bounceAfterScale") Optional bounceAfterScale,
      @JsonProperty("skipHealthchecks") Optional skipHealthchecks,
      @JsonProperty("emailConfigurationOverrides") Optional>> emailConfigurationOverrides,
      @JsonProperty("daemon") @Deprecated Optional daemon, @JsonProperty("hideEvenNumberAcrossRacks") Optional hideEvenNumberAcrossRacksHint,
      @JsonProperty("taskLogErrorRegex") Optional taskLogErrorRegex, @JsonProperty("taskLogErrorRegexCaseSensitive") Optional taskLogErrorRegexCaseSensitive) {
    this.id = checkNotNull(id, "id cannot be null");
    this.owners = owners;
    this.numRetriesOnFailure = numRetriesOnFailure;
    this.schedule = schedule;
    this.rackSensitive = rackSensitive;
    this.instances = instances;
    this.loadBalanced = loadBalanced;
    this.killOldNonLongRunningTasksAfterMillis = killOldNonLongRunningTasksAfterMillis;
    this.scheduleType = scheduleType;
    this.quartzSchedule = quartzSchedule;
    this.rackAffinity = rackAffinity;
    this.slavePlacement = slavePlacement;
    this.requiredSlaveAttributes = requiredSlaveAttributes;
    this.allowedSlaveAttributes = allowedSlaveAttributes;
    this.scheduledExpectedRuntimeMillis = scheduledExpectedRuntimeMillis;
    this.waitAtLeastMillisAfterTaskFinishesForReschedule = waitAtLeastMillisAfterTaskFinishesForReschedule;
    this.group = group;
    this.readOnlyGroups = readOnlyGroups;
    this.bounceAfterScale = bounceAfterScale;
    this.emailConfigurationOverrides = emailConfigurationOverrides;
    this.skipHealthchecks = skipHealthchecks;
    this.hideEvenNumberAcrossRacksHint = hideEvenNumberAcrossRacksHint;
    this.taskLogErrorRegex = taskLogErrorRegex;
    this.taskLogErrorRegexCaseSensitive = taskLogErrorRegexCaseSensitive;
    if (requestType == null) {
      this.requestType = RequestType.fromDaemonAndScheduleAndLoadBalanced(schedule, daemon, loadBalanced);
    } else {
      this.requestType = requestType;
    }
  }

  public SingularityRequestBuilder toBuilder() {
    return new SingularityRequestBuilder(id, requestType)
    .setLoadBalanced(loadBalanced)
    .setInstances(instances)
    .setNumRetriesOnFailure(numRetriesOnFailure)
    .setOwners(copyOfList(owners))
    .setRackSensitive(rackSensitive)
    .setSchedule(schedule)
    .setKillOldNonLongRunningTasksAfterMillis(killOldNonLongRunningTasksAfterMillis)
    .setScheduleType(scheduleType)
    .setQuartzSchedule(quartzSchedule)
    .setRackAffinity(copyOfList(rackAffinity))
    .setWaitAtLeastMillisAfterTaskFinishesForReschedule(waitAtLeastMillisAfterTaskFinishesForReschedule)
    .setSlavePlacement(slavePlacement)
    .setRequiredSlaveAttributes(requiredSlaveAttributes)
    .setAllowedSlaveAttributes(allowedSlaveAttributes)
    .setScheduledExpectedRuntimeMillis(scheduledExpectedRuntimeMillis)
    .setGroup(group)
    .setReadOnlyGroups(readOnlyGroups)
    .setBounceAfterScale(bounceAfterScale)
    .setEmailConfigurationOverrides(emailConfigurationOverrides)
    .setSkipHealthchecks(skipHealthchecks)
    .setHideEvenNumberAcrossRacksHint(hideEvenNumberAcrossRacksHint)
    .setTaskLogErrorRegex(taskLogErrorRegex)
    .setTaskLogErrorRegexCaseSensitive(taskLogErrorRegexCaseSensitive);
  }

  public String getId() {
    return id;
  }

  public Optional> getOwners() {
    return owners;
  }

  public Optional getNumRetriesOnFailure() {
    return numRetriesOnFailure;
  }

  public Optional getSchedule() {
    return schedule;
  }

  public Optional getQuartzSchedule() {
    return quartzSchedule;
  }

  public Optional getInstances() {
    return instances;
  }

  public Optional getRackSensitive() {
    return rackSensitive;
  }

  public Optional getLoadBalanced() {
    return loadBalanced;
  }

  public RequestType getRequestType() {
    return requestType;
  }

  public Optional getKillOldNonLongRunningTasksAfterMillis() {
    return killOldNonLongRunningTasksAfterMillis;
  }

  public Optional getScheduleType() {
    return scheduleType;
  }

  public Optional> getRackAffinity() {
    return rackAffinity;
  }

  public Optional getSlavePlacement() {
    return slavePlacement;
  }

  public Optional getScheduledExpectedRuntimeMillis() {
    return scheduledExpectedRuntimeMillis;
  }

  public Optional> getRequiredSlaveAttributes() {
    return requiredSlaveAttributes;
  }

  public Optional> getAllowedSlaveAttributes() {
    return allowedSlaveAttributes;
  }

  @JsonIgnore
  public int getInstancesSafe() {
    return getInstances().or(1);
  }

  @JsonIgnore
  public boolean isScheduled() {
    return requestType == RequestType.SCHEDULED;
  }

  @JsonIgnore
  public String getQuartzScheduleSafe() {
    if (quartzSchedule.isPresent()) {
      return quartzSchedule.get();
    }

    return schedule.get();
  }

  @JsonIgnore
  public boolean isLongRunning() {
    return requestType.isLongRunning();
  }

  @JsonIgnore
  public boolean isAlwaysRunning() {
    return requestType.isAlwaysRunning();
  }

  @JsonIgnore
  public boolean isOneOff() {
    return requestType == RequestType.ON_DEMAND;
  }

  @JsonIgnore
  public boolean isDeployable() {
    return requestType.isDeployable();
  }

  @JsonIgnore
  public boolean isRackSensitive() {
    return rackSensitive.or(Boolean.FALSE).booleanValue();
  }

  @JsonIgnore
  public boolean isLoadBalanced() {
    return loadBalanced.or(Boolean.FALSE).booleanValue();
  }

  @JsonIgnore
  public ScheduleType getScheduleTypeSafe() {
    return scheduleType.or(ScheduleType.CRON);
  }

  public Optional getWaitAtLeastMillisAfterTaskFinishesForReschedule() {
    return waitAtLeastMillisAfterTaskFinishesForReschedule;
  }

  public Optional getGroup() {
    return group;
  }

  public Optional> getReadOnlyGroups() {
    return readOnlyGroups;
  }

  public Optional getBounceAfterScale() {
    return bounceAfterScale;
  }

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

  public Optional getHideEvenNumberAcrossRacksHint() { return hideEvenNumberAcrossRacksHint; }

  public Optional getTaskLogErrorRegex() { return taskLogErrorRegex; }

  public Optional getTaskLogErrorRegexCaseSensitive() { return taskLogErrorRegexCaseSensitive; }

  @Override
  public String toString() {
    return "SingularityRequest[" +
            "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 +
            ", requiredSlaveAttributes=" + requiredSlaveAttributes +
            ", allowedSlaveAttributes=" + allowedSlaveAttributes +
            ", loadBalanced=" + loadBalanced +
            ", group=" + group +
            ", readOnlyGroups=" + readOnlyGroups +
            ", bounceAfterScale=" + bounceAfterScale +
            ", emailConfigurationOverrides=" + emailConfigurationOverrides +
            ", 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;
    }
    SingularityRequest request = (SingularityRequest) o;
    return Objects.equals(id, request.id) &&
            Objects.equals(requestType, request.requestType) &&
            Objects.equals(owners, request.owners) &&
            Objects.equals(numRetriesOnFailure, request.numRetriesOnFailure) &&
            Objects.equals(schedule, request.schedule) &&
            Objects.equals(quartzSchedule, request.quartzSchedule) &&
            Objects.equals(scheduleType, request.scheduleType) &&
            Objects.equals(killOldNonLongRunningTasksAfterMillis, request.killOldNonLongRunningTasksAfterMillis) &&
            Objects.equals(scheduledExpectedRuntimeMillis, request.scheduledExpectedRuntimeMillis) &&
            Objects.equals(waitAtLeastMillisAfterTaskFinishesForReschedule, request.waitAtLeastMillisAfterTaskFinishesForReschedule) &&
            Objects.equals(instances, request.instances) &&
            Objects.equals(rackSensitive, request.rackSensitive) &&
            Objects.equals(rackAffinity, request.rackAffinity) &&
            Objects.equals(slavePlacement, request.slavePlacement) &&
            Objects.equals(requiredSlaveAttributes, request.requiredSlaveAttributes) &&
            Objects.equals(allowedSlaveAttributes, request.allowedSlaveAttributes) &&
            Objects.equals(loadBalanced, request.loadBalanced) &&
            Objects.equals(group, request.group) &&
            Objects.equals(readOnlyGroups, request.readOnlyGroups) &&
            Objects.equals(bounceAfterScale, request.bounceAfterScale) &&
            Objects.equals(emailConfigurationOverrides, request.emailConfigurationOverrides) &&
            Objects.equals(hideEvenNumberAcrossRacksHint, request.hideEvenNumberAcrossRacksHint) &&
            Objects.equals(taskLogErrorRegex, request.taskLogErrorRegex) &&
            Objects.equals(taskLogErrorRegexCaseSensitive, request.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, emailConfigurationOverrides, hideEvenNumberAcrossRacksHint, taskLogErrorRegex, taskLogErrorRegexCaseSensitive);
  }
}