public static ServiceTaskCallback create(String serviceSelfLink, Enum<?> subStageComplete, Enum<?> subStageFailed) { return create(serviceSelfLink, TaskStage.FINISHED, subStageComplete, TaskStage.FAILED, subStageFailed); }
private AdapterRequest createAdapterRequest(PKSClusterRemovalTaskState task, PKSOperationType operationType) { AdapterRequest adapterRequest = new AdapterRequest(); adapterRequest.operationTypeId = operationType.id; adapterRequest.resourceReference = URI.create(task.endpointLink); adapterRequest.serviceTaskCallback = ServiceTaskCallback.createEmpty(); adapterRequest.customProperties = new HashMap<>(2); adapterRequest.customProperties.put(PKS_CLUSTER_NAME_PROP_NAME, task.clusterName); return adapterRequest; }
protected ServiceTaskCallbackResponse getFailedResponse(ServiceErrorResponse e) { return serviceTaskCallback.getFailedResponse(e); }
private static void fixupTransitionSource(ServiceTaskCallback callback, TransitionSource transitionSource, TaskServiceDocumentHistory task) { ServiceTaskCallbackResponse finishedResponse = callback.getFinishedResponse(); ServiceTaskCallbackResponse failedResponseResponse = callback .getFailedResponse((ServiceErrorResponse) null); for (TaskServiceStageWithLink stage : task.stages) { if (equalsStages(stage, finishedResponse) || equalsStages(stage, failedResponseResponse)) { stage.transitionSource = transitionSource; } } }
protected void patchTaskStage(AdapterRequest state, ServiceErrorResponse errorResponse, ServiceTaskCallbackResponse callbackResponse) { if (state.serviceTaskCallback.isEmpty()) { return; } if (errorResponse != null) { callbackResponse = state.serviceTaskCallback.getFailedResponse(errorResponse); } else if (callbackResponse == null) { callbackResponse = state.serviceTaskCallback.getFinishedResponse(); } URI callbackReference = URI.create(state.serviceTaskCallback.serviceSelfLink); if (callbackReference.getScheme() == null) { callbackReference = UriUtils.buildUri(getHost(), state.serviceTaskCallback.serviceSelfLink); } // tell the parent we are done. We are a mock service, so we get things done, fast. sendRequest(Operation .createPatch(callbackReference) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_QUEUE_FOR_SERVICE_AVAILABILITY) .setBody(callbackResponse) .setCompletion( (o, e) -> { if (e != null) { logWarning( "Notifying parent task %s from mock docker host adapter failed: %s", o.getUri(), Utils.toString(e)); } })); }
protected void notifyCallerService(Closure closureState) { if (closureState.serviceTaskCallback.isEmpty()) { return; } if (closureState.serviceTaskCallback.isExternal()) { sendRequestStateToExternalUrl(closureState.serviceTaskCallback.serviceSelfLink, closureState); } else { ClosureCallbackCompleteResponse callbackResponse = new ClosureCallbackCompleteResponse(); if (closureState.state == TaskStage.FINISHED) { callbackResponse.copy(closureState.serviceTaskCallback.getFinishedResponse()); } else { callbackResponse .copy(closureState.serviceTaskCallback.getFailedResponse(new Exception( closureState.errorMsg))); } sendRequest( Operation.createPatch(this, closureState.serviceTaskCallback.serviceSelfLink) .setBody(callbackResponse) .setCompletion((o, e) -> { if (e != null) { logWarning("Notifying parent task %s failed: %s", o.getUri(), Utils.toString(e)); } })); } }
protected ServiceTaskCallbackResponse getFinishedCallbackResponse(T state) { return state.serviceTaskCallback.getFinishedResponse(); }
protected void completeSubTasksCounter(ServiceTaskCallback taskCallback, Throwable ex) { ServiceTaskCallbackResponse response; if (ex == null) { response = taskCallback.getFinishedResponse(); } else { response = taskCallback.getFailedResponse(ex); } URI uri; if (taskCallback.isExternal()) { uri = URI.create(taskCallback.serviceSelfLink); } else { uri = UriUtils.buildUri(getHost(), taskCallback.serviceSelfLink); } sendRequest(Operation.createPatch(uri) .setBody(response) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_QUEUE_FOR_SERVICE_AVAILABILITY) .setCompletion((o, e) -> { if (e != null) { failTask("Notifying counting task failed: %s", e); } })); }
.toString(); closureState.serviceTaskCallback = ServiceTaskCallback.create ("http://localhost/testcallback"); .getFailedResponse(new Exception("Build Image Exception"));
logWarning(errMsg, state.taskInfo.stage, state.taskSubStage, state.documentExpirationTimeMicros); if (!state.serviceTaskCallback.isEmpty()) { IllegalStateException e = new IllegalStateException(String.format(errMsg, state.taskInfo.stage, state.taskSubStage, .createPatch(this, state.serviceTaskCallback.serviceSelfLink) .setBody(state.serviceTaskCallback .getFailedResponse(e)) .addPragmaDirective( Operation.PRAGMA_DIRECTIVE_QUEUE_FOR_SERVICE_AVAILABILITY)
public String getRequestTrackingLog() { return (serviceTaskCallback == null || serviceTaskCallback.isEmpty()) ? "" : " request: " + serviceTaskCallback.serviceSelfLink; }
protected void notifyCallerService(T state) { if (state.serviceTaskCallback.isEmpty()) { return; state.serviceTaskCallback.serviceSelfLink, state.taskInfo.stage); if (state.serviceTaskCallback.isExternal()) { sendRequestStateToExternalUrl(state.serviceTaskCallback.serviceSelfLink, state); } else {
public static ServiceTaskCallback create(String serviceSelfLink, TaskStage taskStageComplete, Enum<?> subStageComplete, TaskStage taskStageFailed, Enum<?> subStageFailed) { return new ServiceTaskCallback(serviceSelfLink, taskStageComplete, subStageComplete, taskStageFailed, subStageFailed); }
private void patchTaskErrorResponse(MockAdapterRequest state, ServiceErrorResponse errorResponse) { if (state.serviceTaskCallback.isEmpty()) { return; callbackResponse = state.serviceTaskCallback.getFailedResponse(errorResponse); } else { callbackResponse = state.serviceTaskCallback.getFinishedResponse();
protected ServiceTaskCallbackResponse getFinishedResponse() { return serviceTaskCallback.getFinishedResponse(); }
@Override protected ServiceTaskCallbackResponse getFinishedCallbackResponse( CompositionSubTaskState state) { if (state.resourceLinks == null || state.resourceLinks.isEmpty()) { String errMsg = "No resourceLinks found for allocated resources."; logWarning(errMsg); return state.serviceTaskCallback .getFailedResponse(new LocalizableValidationException(errMsg, "request.composition.resource-links.missing")); } else { CallbackCompleteResponse finishedResponse = new CallbackCompleteResponse(); finishedResponse.copy(state.serviceTaskCallback.getFinishedResponse()); finishedResponse.resourceLinks = state.resourceLinks; return finishedResponse; } }
@Override public void handlePatch(Operation op) { AdapterRequest request = op.getBody(AdapterRequest.class); request.validate(); logFine("Processing host operation request %s", request.getRequestTrackingLog()); if (request.operationTypeId.equals(ContainerHostOperationType.PING.id) && ComputeService.FACTORY_LINK.equals(request.resourceReference.getPath())) { directPing(request, op); } else if (request.operationTypeId.equals(ContainerHostOperationType.INFO.id) && ComputeService.FACTORY_LINK.equals(request.resourceReference.getPath())) { directInfo(request, op); } else if (request.operationTypeId.equals(ContainerHostOperationType.LIST_ENTITIES.id) && request.serviceTaskCallback.isEmpty()) { getComputeHost(request, op, request.resourceReference, context -> listEntities(request, context, op, direct)); } else { getComputeHost(request, op, request.resourceReference, context -> processOperation(request, context)); op.complete(); } }
@Test public void testTimeout() throws Throwable { ExtensibilitySubscriptionCallback state = createExtensibilityCallback( ExtensibilitySubscriptionCallback.Status.BLOCKED); state.due = LocalDateTime.now().plus(5, SECONDS); state.serviceTaskCallback = new ServiceTaskCallback(); state.serviceTaskCallback.serviceSelfLink = TestStatelessService.SELF_LINK; state.replyPayload = new ServiceTaskCallbackResponse(); state.replyPayload.taskInfo = TaskState.createAsStarted(); state.replyPayload.taskSubStage = DefaultSubStage.CREATED; state.taskStateJson = TestStatelessService.class.getSimpleName(); DeferredResult<Void> done = new DeferredResult<>(); this.host.startService(new TestStatelessService(done)); this.host.waitForServiceAvailable(TestStatelessService.SELF_LINK); URI uri = UriUtils.buildUri(host, ExtensibilitySubscriptionCallbackService.FACTORY_LINK); sender.sendPostAndWait(uri, state, ExtensibilitySubscriptionCallback.class); this.waitFor("Task did not time out.", () -> done.isDone()); }
private ServiceTaskCallback createServiceCallBack(String taskLink) { return ServiceTaskCallback.create(taskLink); }
if (request.serviceTaskCallback.isEmpty()) { logFine("No callback provided to Kubernetes adapter service for resource: %s.", request.resourceReference); case FINISHED: if (callbackResponse == null) { callbackResponse = request.serviceTaskCallback.getFinishedResponse(); case FAILED: default: callbackResponse = request.serviceTaskCallback.getFailedResponse( exception == null ? new Exception("Adapter Exception.") : exception); break;