com.hubspot.singularity.resources.AbstractMachineResource Maven / Gradle / Ivy

Go to download
package com.hubspot.singularity.resources;

import static com.hubspot.singularity.WebExceptions.checkNotFound;

import java.util.List;
import java.util.UUID;

import com.google.common.base.Optional;
import com.hubspot.mesos.JavaUtils;
import com.hubspot.singularity.MachineState;
import com.hubspot.singularity.SingularityDeleteResult;
import com.hubspot.singularity.SingularityAction;
import com.hubspot.singularity.SingularityMachineAbstraction;
import com.hubspot.singularity.SingularityUser;
import com.hubspot.singularity.api.SingularityMachineChangeRequest;
import com.hubspot.singularity.auth.SingularityAuthorizationHelper;
import com.hubspot.singularity.data.AbstractMachineManager;
import com.hubspot.singularity.data.AbstractMachineManager.StateChangeResult;
import com.hubspot.singularity.data.SingularityValidator;
import com.hubspot.singularity.expiring.SingularityExpiringMachineState;
import com.sun.jersey.api.ConflictException;
import com.sun.jersey.api.NotFoundException;

public abstract class AbstractMachineResource> {

  protected final AbstractMachineManager manager;
  protected final Optional user;

  protected final SingularityAuthorizationHelper authorizationHelper;
  private final SingularityValidator validator;

  public AbstractMachineResource(AbstractMachineManager manager, SingularityAuthorizationHelper authorizationHelper, Optional user, SingularityValidator validator) {
    this.manager = manager;
    this.authorizationHelper = authorizationHelper;
    this.user = user;
    this.validator = validator;
  }

  protected void remove(String objectId) {
    authorizationHelper.checkAdminAuthorization(user);
    checkNotFound(manager.deleteObject(objectId) == SingularityDeleteResult.DELETED, "Couldn't find dead %s with id %s", getObjectTypeString(), objectId);
  }

  protected void cancelExpiring(String objectId) {
    authorizationHelper.checkAdminAuthorization(user);
    manager.deleteExpiringObject(objectId);
  }

  protected List getExpiringStateChanges() {
    authorizationHelper.checkAdminAuthorization(user);
    return manager.getExpiringObjects();
  }

  protected abstract String getObjectTypeString();

  private void changeState(String objectId, MachineState newState, Optional changeRequest, Optional user) {
    Optional message = Optional.absent();

    if (changeRequest.isPresent()) {
      message = changeRequest.get().getMessage();
    }

    StateChangeResult result = manager.changeState(objectId, newState, message, user);

    switch (result) {
      case FAILURE_NOT_FOUND:
        throw new NotFoundException(String.format("Couldn't find an active %s with id %s (result: %s)", getObjectTypeString(), objectId, result.name()));
      case FAILURE_ALREADY_AT_STATE:
      case FAILURE_ILLEGAL_TRANSITION:
        throw new ConflictException(String.format("%s - %s %s is in %s state", result.name(), getObjectTypeString(), objectId, newState));
      default:
        break;
    }
  }

  protected void decommission(String objectId, Optional decommissionRequest, Optional queryUser, SingularityAction action) {
    authorizationHelper.checkAdminAuthorization(user);
    validator.checkActionEnabled(action);
    validator.validateExpiringMachineStateChange(decommissionRequest, MachineState.STARTING_DECOMMISSION, manager.getExpiringObject(objectId));
    changeState(objectId, MachineState.STARTING_DECOMMISSION, decommissionRequest, queryUser);
    saveExpiring(decommissionRequest, queryUser, objectId);
  }

  protected void freeze(String objectId, Optional freezeRequest, Optional queryUser, SingularityAction action) {
    authorizationHelper.checkAdminAuthorization(user);
    validator.checkActionEnabled(action);
    validator.validateExpiringMachineStateChange(freezeRequest, MachineState.FROZEN, manager.getExpiringObject(objectId));
    changeState(objectId, MachineState.FROZEN, freezeRequest, queryUser);
    saveExpiring(freezeRequest, queryUser, objectId);
  }

  protected void activate(String objectId, Optional activateRequest, Optional queryUser, SingularityAction action) {
    authorizationHelper.checkAdminAuthorization(user);
    validator.checkActionEnabled(action);
    validator.validateExpiringMachineStateChange(activateRequest, MachineState.ACTIVE, manager.getExpiringObject(objectId));
    changeState(objectId, MachineState.ACTIVE, activateRequest, queryUser);
    saveExpiring(activateRequest, queryUser, objectId);
  }

  private void saveExpiring(Optional changeRequest, Optional queryUser, String objectId) {
    if (changeRequest.isPresent() && changeRequest.get().getDurationMillis().isPresent()) {
      manager.saveExpiringObject(
        new SingularityExpiringMachineState(
          queryUser,
          System.currentTimeMillis(),
          changeRequest.get().getActionId().or(UUID.randomUUID().toString()),
          changeRequest.get(),
          objectId,
          changeRequest.get().getRevertToState().get(),
          Optional.of(changeRequest.get().isKillTasksOnDecommissionTimeout())
          ),
        objectId);
    }
  }
}