public ClusteringTaskService() { super(ClusteringTaskState.class, SubStage.class, DISPLAY_NAME); super.toggleOption(ServiceOption.PERSISTENCE, true); super.toggleOption(ServiceOption.REPLICATION, true); super.toggleOption(ServiceOption.OWNER_SELECTION, true); super.transientSubStages = SubStage.TRANSIENT_SUB_STAGES; }
@Override protected TaskStatusState fromTask(TaskServiceDocument<SubStage> state) { final TaskStatusState statusTask = super.fromTask(state); if (SubStage.CONTEXT_PREPARED == state.taskSubStage) { statusTask.name = ((ContainerAllocationTaskState) state).descName; } return statusTask; }
protected void handleFailedStagePatch(T state) { ServiceErrorResponse err = state.taskInfo.failure; logWarning("Task failed with: %s", err == null ? "n.a." : err.message); if (err != null && err.stackTrace != null) { logFine("Task failure stack trace: %s", err.stackTrace); } notifyCallerService(state); }
public PKSClusterProvisioningTaskService() { super(PKSProvisioningTaskState.class, DefaultSubStage.class, DISPLAY_NAME); super.toggleOption(ServiceOption.PERSISTENCE, true); super.toggleOption(ServiceOption.REPLICATION, true); super.toggleOption(ServiceOption.OWNER_SELECTION, true); super.toggleOption(ServiceOption.PERIODIC_MAINTENANCE, true); super.setMaintenanceIntervalMicros(POLL_PKS_ENDPOINT_INTERVAL_MICROS); super.transientSubStages = DefaultSubStage.TRANSIENT_SUB_STAGES; }
@Override public void handlePatch(Operation patch) { if (!checkForBody(patch)) { return; } T patchBody = getBody(patch); T state = getState(patch); // validates AND transitions the stage to the next state by using the patchBody if (validateStageTransitionAndState(patch, patchBody, state)) { // the patch operation is assumed to be already completed/failed in this case return; } patch.complete(); checkAndHandleSubscriptions(state, patch); }
protected void handleStagePatch(T state) { if (getInstance().shouldFail(state.taskSubStage)) { failTask("Fail task in stage [" + state.taskSubStage + "], based on DeploymentProfileConfig", null); return; updateRequestTracker(state); case CREATED: case STARTED: handleStartedStagePatch(state); break; case FAILED: handleFailedStagePatch(state); break; case FINISHED: handleFinishedStagePatch(state); break; case CANCELLED: sendSelfDelete();
protected void updateRequestTracker(T state, int retryCount) { if (state != null && state.requestTrackerLink != null) { sendRequest(Operation .createPatch(this, state.requestTrackerLink) .setBody(fromTask(state)) .setCompletion((o, ex) -> { if (ex != null) { logFine("CancellationException: Failed to update request tracker:" + " %s", state.requestTrackerLink); || TaskStage.FAILED.name().equals(state.taskInfo.stage.name()) && retryCount > 0) { getHost().schedule( () -> updateRequestTracker(state, retryCount - 1), QueryUtil.QUERY_RETRY_INTERVAL_MILLIS, TimeUnit.MILLISECONDS); } else { logWarning("Failed to update request tracker: %s. Error: %s", state.requestTrackerLink, Utils.toString(ex)); logFine("Task doesn't have a requestTrackerLink set: %s ", state.documentSelfLink);
logWarning("Task patched to failed when already in failed state. %s", refererLogPart); patch.complete(); return true; && DefaultSubStage.ERROR.name().equals(currentState.taskSubStage.name()) && TaskStage.FAILED == currentState.taskInfo.stage) { logWarning("Task already failed.%s", refererLogPart); logWarning("Can't move from %s(%s) to %s(%s).%s", currentState.taskInfo.stage, currentState.taskSubStage, patchBody.taskInfo.stage, patchBody.taskSubStage, refererLogPart); if (patchBody.taskInfo.stage == currentState.taskInfo.stage && !transientSubStages.contains(patchBody.taskSubStage)) { logWarning("Can't move from %s(%s) to %s(%s).%s", currentState.taskInfo.stage, currentState.taskSubStage, patchBody.taskInfo.stage, patchBody.taskSubStage, refererLogPart); log(this.logLevel, "Moving from %s(%s) to %s(%s).%s", currentState.taskInfo.stage, currentState.taskSubStage, patchBody.taskInfo.stage, patchBody.taskSubStage, refererLogPart); adjustStat(patchBody.taskInfo.stage.toString(), 1); autoMergeState(patch, patchBody, currentState); if (currentState.documentExpirationTimeMicros == 0) { currentState.documentExpirationTimeMicros = currentExpiration; customStateValidationAndMerge(patch, patchBody, currentState);
@Override public void handleStop(Operation delete) { try { if (delete.hasBody()) { T task = getBody(delete); if (ServiceUtils.isExpired(task)) { handleExpiration(task); } } } catch (Throwable t) { logWarning("Error while stopping task service [%s]: %s", getSelfLink(), Utils.toString(t)); } finally { super.handleStop(delete); } }
protected boolean validateStateOnStart(T state, Operation startPost) throws IllegalArgumentException { // validate based on annotations Utils.validateState(getStateDescription(), state); // apply optional custom validation validateStateOnStart(state); return false; }
@Override public void handleExpiration(PKSProvisioningTaskState task) { super.handleExpiration(task); if (task.taskSubStage == PROCESSING) { logWarning("Task %s has expired, notifying parent task.", task.documentSelfLink); Exception e = new Exception("PKS cluster was provisioned, but is not reachable. Check" + " network connectivity."); task.taskInfo.failure = ServiceErrorResponse.create(e, 0); notifyCallerService(task); } }
private boolean validateNewState(T state, Operation startPost) { if (state.documentVersion > 0) { logWarning("Document version on create is : %s", state.documentVersion); return false; } if (state.serviceTaskCallback == null) { state.serviceTaskCallback = ServiceTaskCallback.createEmpty(); } if (state.taskInfo == null) { state.taskInfo = new TaskState(); state.taskInfo.stage = TaskStage.CREATED; } if (state.taskSubStage == null) { state.taskSubStage = Enum.valueOf(subStageType, DefaultSubStage.CREATED.name()); } if (state.documentExpirationTimeMicros == 0) { state.documentExpirationTimeMicros = ServiceUtils .getDefaultTaskExpirationTimeInMicros(); } return validateStateOnStart(state, startPost); }
@Override protected boolean validateStateOnStart(CallbackServiceHandlerState state, Operation startPost) throws IllegalArgumentException { super.validateStateOnStart(state, startPost); return true;//make sure that super.handleCreate() above doesn't close the startPost operation }
@Override protected void handleFailedStagePatch(PKSClusterResizeTaskState state) { super.handleFailedStagePatch(state); resumeHost(state, () -> { }); }
protected void handleFinishedStagePatch(T state) { notifyCallerService(state); }
super.autoMergeState(patch, patchBody, currentState);
@Override protected boolean validateStageTransitionAndState(Operation patch, CompositionSubTaskState patchBody, CompositionSubTaskState currentState) { if (currentState.taskSubStage.ordinal() > patchBody.taskSubStage.ordinal() && patchBody.taskSubStage == SubStage.EXECUTE) { // ignore out-of-order EXECUTE from parent task: task was moved to EXECUTE by a // dependent task logFine("Ignoring subStage move from %s(%s) to %s(%s). Caller: [%s]", currentState.taskInfo.stage, currentState.taskSubStage, patchBody.taskInfo.stage, patchBody.taskSubStage, patch.getReferer()); patch.complete(); return true; } return super.validateStageTransitionAndState(patch, patchBody, currentState); }
public PKSClusterRemovalTaskService() { super(PKSClusterRemovalTaskState.class, SubStage.class, DISPLAY_NAME); super.toggleOption(ServiceOption.PERSISTENCE, true); super.toggleOption(ServiceOption.REPLICATION, true); super.toggleOption(ServiceOption.OWNER_SELECTION, true); super.toggleOption(ServiceOption.PERIODIC_MAINTENANCE, true); super.setMaintenanceIntervalMicros(POLL_PKS_ENDPOINT_INTERVAL_MICROS); super.transientSubStages = SubStage.TRANSIENT_SUB_STAGES; }
@Override public void handleExpiration(PKSClusterResizeTaskState task) { super.handleExpiration(task); if (task.taskSubStage == PROCESSING) { logWarning("Task %s has expired, notifying parent task.", task.documentSelfLink); resumeHost(task, () -> { }); notifyCallerService(task); } }
@Override protected boolean validateStateOnStart(RequestBrokerState state, Operation startOpr) { super.validateStateOnStart(state, startOpr); validateUserAuthorization(state, startOpr) .whenComplete((ignore, ex) -> { if (ex != null) { startOpr.fail(ex); return; } boolean completed = createRequestTrackerIfNoneProvided(state, startOpr); if (!completed) { startOpr.complete(); } }); return true; }