@Override public void getTasksInProgress(TaskServicePb.TasksInProgressRequest req, StreamObserver<TaskServicePb.TasksInProgressResponse> response) { final String startKey = GRPC_HELPER.optional(req.getStartKey()); final int count = GRPC_HELPER.optionalOr(req.getCount(), MAX_TASK_COUNT); try { response.onNext( TaskServicePb.TasksInProgressResponse.newBuilder().addAllTasks( taskService.getTasks(req.getTaskType(), startKey, count) .stream() .map(PROTO_MAPPER::toProto)::iterator ).build() ); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
void onError(StreamObserver<?> response, Throwable t) { logger.error("internal exception during GRPC request", t); response.onError(throwableToStatusException(t)); }
@Override public void pauseWorkflow(WorkflowServicePb.PauseWorkflowRequest req, StreamObserver<WorkflowServicePb.PauseWorkflowResponse> response) { try { workflowService.pauseWorkflow(req.getWorkflowId()); response.onNext(WorkflowServicePb.PauseWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void poll(TaskServicePb.PollRequest req, StreamObserver<TaskServicePb.PollResponse> response) { try { List<Task> tasks = executionService.poll(req.getTaskType(), req.getWorkerId(), GRPC_HELPER.optional(req.getDomain()), 1, POLL_TIMEOUT_MS); if (!tasks.isEmpty()) { TaskPb.Task t = PROTO_MAPPER.toProto(tasks.get(0)); response.onNext(TaskServicePb.PollResponse.newBuilder() .setTask(t) .build() ); } response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
private void doSearch(boolean searchByTask, SearchPb.Request req, StreamObserver<WorkflowServicePb.WorkflowSummarySearchResult> response) { final int start = req.getStart(); final int size = GRPC_HELPER.optionalOr(req.getSize(), maxSearchSize); final List<String> sort = convertSort(req.getSort()); final String freeText = GRPC_HELPER.optionalOr(req.getFreeText(), "*"); final String query = req.getQuery(); if (size > maxSearchSize) { response.onError( Status.INVALID_ARGUMENT .withDescription("Cannot return more than "+maxSearchSize+" results") .asRuntimeException() ); return; } SearchResult<WorkflowSummary> search; if (searchByTask) { search = workflowService.searchWorkflowsByTasks(start, size, sort, freeText,query); } else { search = workflowService.searchWorkflows(start, size, sort, freeText, query); } response.onNext( WorkflowServicePb.WorkflowSummarySearchResult.newBuilder() .setTotalHits(search.getTotalHits()) .addAllResults( search.getResults().stream().map(PROTO_MAPPER::toProto)::iterator ).build() ); response.onCompleted(); }
@Override public void getWorkflow(MetadataServicePb.GetWorkflowRequest req, StreamObserver<MetadataServicePb.GetWorkflowResponse > response) { try { WorkflowDef workflowDef = service.getWorkflowDef(req.getName(), GRPC_HELPER.optional(req.getVersion())); WorkflowDefPb.WorkflowDef workflow = PROTO_MAPPER.toProto(workflowDef); response.onNext(MetadataServicePb.GetWorkflowResponse.newBuilder() .setWorkflow(workflow) .build() ); response.onCompleted(); } catch (ApplicationException e) { // TODO replace this with gRPC exception interceptor. response.onError(Status.NOT_FOUND .withDescription("No such workflow found by name=" + req.getName()) .asRuntimeException() ); } }
@Override public void decideWorkflow(WorkflowServicePb.DecideWorkflowRequest req, StreamObserver<WorkflowServicePb.DecideWorkflowResponse> response) { try { workflowService.decideWorkflow(req.getWorkflowId()); response.onNext(WorkflowServicePb.DecideWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void startWorkflow(StartWorkflowRequestPb.StartWorkflowRequest pbRequest, StreamObserver<WorkflowServicePb.StartWorkflowResponse> response) { // TODO: better handling of optional 'version' final StartWorkflowRequest request = PROTO_MAPPER.fromProto(pbRequest); try { String id = workflowService.startWorkflow(pbRequest.getName(), GRPC_HELPER.optional(request.getVersion()),request.getCorrelationId(), request.getInput(), request.getExternalInputPayloadStoragePath(), request.getTaskToDomain(), request.getWorkflowDef()); response.onNext(WorkflowServicePb.StartWorkflowResponse.newBuilder() .setWorkflowId(id) .build() ); response.onCompleted(); } catch (ApplicationException ae) { if (ae.getCode().equals(ApplicationException.Code.NOT_FOUND)) { response.onError(Status.NOT_FOUND .withDescription("No such workflow found by name="+request.getName()) .asRuntimeException() ); } else { GRPC_HELPER.onError(response, ae); } } }
@Override public void batchPoll(TaskServicePb.BatchPollRequest req, StreamObserver<TaskPb.Task> response) { final int count = GRPC_HELPER.optionalOr(req.getCount(), 1); final int timeout = GRPC_HELPER.optionalOr(req.getTimeout(), POLL_TIMEOUT_MS); if (timeout > MAX_POLL_TIMEOUT_MS) { response.onError(Status.INVALID_ARGUMENT .withDescription("longpoll timeout cannot be longer than " + MAX_POLL_TIMEOUT_MS + "ms") .asRuntimeException() ); return; } try { List<Task> polledTasks = taskService.batchPoll(req.getTaskType(), req.getWorkerId(), GRPC_HELPER.optional(req.getDomain()), count, timeout); LOGGER.info("polled tasks: "+polledTasks); polledTasks.stream().map(PROTO_MAPPER::toProto).forEach(response::onNext); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void resumeWorkflow(WorkflowServicePb.ResumeWorkflowRequest req, StreamObserver<WorkflowServicePb.ResumeWorkflowResponse> response) { try { workflowService.resumeWorkflow(req.getWorkflowId()); response.onNext(WorkflowServicePb.ResumeWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void resetWorkflowCallbacks(WorkflowServicePb.ResetWorkflowCallbacksRequest req, StreamObserver<WorkflowServicePb.ResetWorkflowCallbacksResponse> response) { try { workflowService.resetWorkflow(req.getWorkflowId()); response.onNext(WorkflowServicePb.ResetWorkflowCallbacksResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void retryWorkflow(WorkflowServicePb.RetryWorkflowRequest req, StreamObserver<WorkflowServicePb.RetryWorkflowResponse> response) { try { workflowService.retryWorkflow(req.getWorkflowId()); response.onNext(WorkflowServicePb.RetryWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void getWorkflowStatus(WorkflowServicePb.GetWorkflowStatusRequest req, StreamObserver<WorkflowPb.Workflow> response) { try { Workflow workflow = workflowService.getExecutionStatus(req.getWorkflowId(), req.getIncludeTasks()); response.onNext(PROTO_MAPPER.toProto(workflow)); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void removeWorkflow(WorkflowServicePb.RemoveWorkflowRequest req, StreamObserver<WorkflowServicePb.RemoveWorkflowResponse> response) { try { workflowService.deleteWorkflow(req.getWorkflodId(), req.getArchiveWorkflow()); response.onNext(WorkflowServicePb.RemoveWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void restartWorkflow(WorkflowServicePb.RestartWorkflowRequest req, StreamObserver<WorkflowServicePb.RestartWorkflowResponse> response) { try { workflowService.restartWorkflow(req.getWorkflowId(), req.getUseLatestDefinitions()); response.onNext(WorkflowServicePb.RestartWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void terminateWorkflow(WorkflowServicePb.TerminateWorkflowRequest req, StreamObserver<WorkflowServicePb.TerminateWorkflowResponse> response) { try { workflowService.terminateWorkflow(req.getWorkflowId(), req.getReason()); response.onNext(WorkflowServicePb.TerminateWorkflowResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void ackTask(TaskServicePb.AckTaskRequest req, StreamObserver<TaskServicePb.AckTaskResponse> response) { try { boolean ack = taskService.ackTaskReceived(req.getTaskId()); response.onNext(TaskServicePb.AckTaskResponse.newBuilder().setAck(ack).build()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void skipTaskFromWorkflow(WorkflowServicePb.SkipTaskRequest req, StreamObserver<WorkflowServicePb.SkipTaskResponse> response) { try { SkipTaskRequest skipTask = PROTO_MAPPER.fromProto(req.getRequest()); workflowService.skipTaskFromWorkflow(req.getWorkflowId(),req.getTaskReferenceName(), skipTask); response.onNext(WorkflowServicePb.SkipTaskResponse.getDefaultInstance()); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void rerunWorkflow(RerunWorkflowRequestPb.RerunWorkflowRequest req, StreamObserver<WorkflowServicePb.RerunWorkflowResponse> response) { try { String id = workflowService.rerunWorkflow(req.getReRunFromWorkflowId(), PROTO_MAPPER.fromProto(req)); response.onNext(WorkflowServicePb.RerunWorkflowResponse.newBuilder() .setWorkflowId(id) .build() ); response.onCompleted(); } catch (Exception e) { GRPC_HELPER.onError(response, e); } }
@Override public void check(HealthCheckRequest request, StreamObserver<HealthCheckResponse> responseObserver) { try { if (healthCheck.check().get().isHealthy()) { responseObserver.onNext( HealthCheckResponse.newBuilder().setStatus(HealthCheckResponse.ServingStatus.SERVING).build() ); } else { responseObserver.onNext( HealthCheckResponse.newBuilder().setStatus(HealthCheckResponse.ServingStatus.NOT_SERVING).build() ); } } catch (Exception ex) { GRPC_HELPER.onError(responseObserver, ex); } finally { responseObserver.onCompleted(); } } }