public WorkflowClient(String address, int port) { super(address, port); this.stub = WorkflowServiceGrpc.newBlockingStub(this.channel); }
public TaskClient(String address, int port) { super(address, port); this.stub = TaskServiceGrpc.newBlockingStub(this.channel); }
/** * Updates an existing task definition * * @param taskDef the task definition to be updated */ public void updateTaskDef(TaskDef taskDef) { Preconditions.checkNotNull(taskDef, "Task definition cannot be null"); stub.updateTask( MetadataServicePb.UpdateTaskRequest.newBuilder() .setTask(protoMapper.toProto(taskDef)) .build() ); }
/** * Retrieve the task definition of a given task type * * @param taskType type of task for which to retrieve the definition * @return Task Definition for the given task type */ public TaskDef getTaskDef(String taskType) { Preconditions.checkArgument(StringUtils.isNotBlank(taskType), "Task type cannot be blank"); return protoMapper.fromProto( stub.getTask(MetadataServicePb.GetTaskRequest.newBuilder() .setTaskType(taskType) .build() ).getTask() ); }
/** * Retrieve information about the task * * @param taskId ID of the task * @return Task details */ public Task getTaskDetails(String taskId) { Preconditions.checkArgument(StringUtils.isNotBlank(taskId), "Task id cannot be blank"); return protoMapper.fromProto( stub.getTask(TaskServicePb.GetTaskRequest.newBuilder() .setTaskId(taskId) .build() ).getTask() ); }
/** * Register a workflow definition with the server * * @param workflowDef the workflow definition */ public void registerWorkflowDef(WorkflowDef workflowDef) { Preconditions.checkNotNull(workflowDef, "Worfklow definition cannot be null"); stub.createWorkflow( MetadataServicePb.CreateWorkflowRequest.newBuilder() .setWorkflow(protoMapper.toProto(workflowDef)) .build() ); }
/** * Updates the result of a task execution. * * @param taskResult TaskResults to be updated. */ public void updateTask(TaskResult taskResult) { Preconditions.checkNotNull(taskResult, "Task result cannot be null"); stub.updateTask(TaskServicePb.UpdateTaskRequest.newBuilder() .setResult(protoMapper.toProto(taskResult)) .build() ); }
/** * Reruns the workflow from a specific task * * @param rerunWorkflowRequest the request containing the task to rerun from * @return the id of the workflow */ public String rerunWorkflow(RerunWorkflowRequest rerunWorkflowRequest) { Preconditions.checkNotNull(rerunWorkflowRequest, "RerunWorkflowRequest cannot be null"); return stub.rerunWorkflow( protoMapper.toProto(rerunWorkflowRequest) ).getWorkflowId(); }
/** * Starts a workflow * * @param startWorkflowRequest the {@link StartWorkflowRequest} object to start the workflow * @return the id of the workflow instance that can be used for tracking */ public String startWorkflow(StartWorkflowRequest startWorkflowRequest) { Preconditions.checkNotNull(startWorkflowRequest, "StartWorkflowRequest cannot be null"); return stub.startWorkflow( protoMapper.toProto(startWorkflowRequest) ).getWorkflowId(); }
@Override public void getQueueSizes(EventServicePb.GetQueueSizesRequest req, StreamObserver<EventServicePb.GetQueueSizesResponse> response) { EventServicePb.GetQueueSizesResponse.Builder builder = EventServicePb.GetQueueSizesResponse.newBuilder(); for (Map.Entry<String, Map<String, Long>> pair : ((Map<String, Map<String, Long>>)eventService.getEventQueues(true)).entrySet()) { builder.putEventToQueueInfo(pair.getKey(), EventServicePb.GetQueueSizesResponse.QueueInfo.newBuilder() .putAllQueueSizes(pair.getValue()).build() ); } response.onNext(builder.build()); response.onCompleted(); }
@Override public void updateTask(MetadataServicePb.UpdateTaskRequest req, StreamObserver<MetadataServicePb.UpdateTaskResponse> response) { TaskDef task = PROTO_MAPPER.fromProto(req.getTask()); service.updateTaskDef(task); response.onNext(MetadataServicePb.UpdateTaskResponse.getDefaultInstance()); response.onCompleted(); }
@Override public void createWorkflow(MetadataServicePb.CreateWorkflowRequest req, StreamObserver<MetadataServicePb.CreateWorkflowResponse> response) { WorkflowDef workflow = PROTO_MAPPER.fromProto(req.getWorkflow()); service.registerWorkflowDef(workflow); response.onNext(MetadataServicePb.CreateWorkflowResponse.getDefaultInstance()); response.onCompleted(); }
@Override public void addEventHandler(EventServicePb.AddEventHandlerRequest req, StreamObserver<EventServicePb.AddEventHandlerResponse> response) { metadataService.addEventHandler(PROTO_MAPPER.fromProto(req.getHandler())); response.onNext(EventServicePb.AddEventHandlerResponse.getDefaultInstance()); response.onCompleted(); }
@Override public void updateEventHandler(EventServicePb.UpdateEventHandlerRequest req, StreamObserver<EventServicePb.UpdateEventHandlerResponse> response) { metadataService.updateEventHandler(PROTO_MAPPER.fromProto(req.getHandler())); response.onNext(EventServicePb.UpdateEventHandlerResponse.getDefaultInstance()); response.onCompleted(); }
public int getQueueSizeForTask(String taskType) { Preconditions.checkArgument(StringUtils.isNotBlank(taskType), "Task type cannot be blank"); TaskServicePb.QueueSizesResponse sizes = stub.getQueueSizesForTasks( TaskServicePb.QueueSizesRequest.newBuilder() .addTaskTypes(taskType) .build() ); return sizes.getQueueForTaskOrDefault(taskType, 0); } }
@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); } }
/** * Resume a paused workflow by workflow id * * @param workflowId the workflow id of the paused workflow */ public void resumeWorkflow(String workflowId) { Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank"); stub.resumeWorkflow(WorkflowServicePb.ResumeWorkflowRequest.newBuilder() .setWorkflowId(workflowId) .build() ); }
/** * Resets the callback times of all IN PROGRESS tasks to 0 for the given workflow * * @param workflowId the id of the workflow */ public void resetCallbacksForInProgressTasks(String workflowId) { Preconditions.checkArgument(StringUtils.isNotBlank(workflowId), "workflow id cannot be blank"); stub.resetWorkflowCallbacks(WorkflowServicePb.ResetWorkflowCallbacksRequest.newBuilder() .setWorkflowId(workflowId) .build() ); }
@Override public void getQueueSizesForTasks(TaskServicePb.QueueSizesRequest req, StreamObserver<TaskServicePb.QueueSizesResponse> response) { Map<String, Integer> sizes = taskService.getTaskQueueSizes(req.getTaskTypesList()); response.onNext( TaskServicePb.QueueSizesResponse.newBuilder() .putAllQueueForTask(sizes) .build() ); response.onCompleted(); }
public MetadataClient(String address, int port) { super(address, port); this.stub = MetadataServiceGrpc.newBlockingStub(this.channel); }