How to use com.netflix.conductor.grpc

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);
}