Package io.camunda.zeebe.gateway.protocol

Class GatewayGrpc.GatewayFutureStub

java.lang.Object
io.grpc.stub.AbstractStub<S>
io.grpc.stub.AbstractFutureStub<GatewayGrpc.GatewayFutureStub>
io.camunda.zeebe.gateway.protocol.GatewayGrpc.GatewayFutureStub
Enclosing class:
GatewayGrpc
public static final class GatewayGrpc.GatewayFutureStub extends io.grpc.stub.AbstractFutureStub<GatewayGrpc.GatewayFutureStub>
A stub to allow clients to do ListenableFuture-style rpc calls to service Gateway.

  • Method Details

    • build

      protected GatewayGrpc.GatewayFutureStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions)
      Specified by:
      build in class io.grpc.stub.AbstractStub<GatewayGrpc.GatewayFutureStub>

    • cancelProcessInstance

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.CancelProcessInstanceResponse> cancelProcessInstance(GatewayOuterClass.CancelProcessInstanceRequest request)
      Cancels a running process instance
Errors:
NOT_FOUND:
- no process instance exists with the given key

    • completeJob

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.CompleteJobResponse> completeJob(GatewayOuterClass.CompleteJobRequest request)
      Completes a job with the given variables, which allows completing the associated service task.
Errors:
NOT_FOUND:
- no job exists with the given job key. Note that since jobs are removed once completed,
it could be that this job did exist at some point.
FAILED_PRECONDITION:
- the job was marked as failed. In that case, the related incident must be resolved before
the job can be activated again and completed.

    • createProcessInstance

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.CreateProcessInstanceResponse> createProcessInstance(GatewayOuterClass.CreateProcessInstanceRequest request)
      Creates and starts an instance of the specified process. The process definition to use to
create the instance can be specified either using its unique key (as returned by
DeployProcess), or using the BPMN process ID and a version. Pass -1 as the version to use the
latest deployed version. Note that only processes with none start events can be started through
this command.
Errors:
NOT_FOUND:
- no process with the given key exists (if processDefinitionKey was given)
- no process with the given process ID exists (if bpmnProcessId was given but version was -1)
- no process with the given process ID and version exists (if both bpmnProcessId and version were given)
FAILED_PRECONDITION:
- the process definition does not contain a none start event; only processes with none
start event can be started manually.
INVALID_ARGUMENT:
- the given variables argument is not a valid JSON document; it is expected to be a valid
JSON document where the root node is an object.

    • createProcessInstanceWithResult

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.CreateProcessInstanceWithResultResponse> createProcessInstanceWithResult(GatewayOuterClass.CreateProcessInstanceWithResultRequest request)
      Behaves similarly to `rpc CreateProcessInstance`, except that a successful response is received when the process completes successfully.

    • evaluateDecision

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.EvaluateDecisionResponse> evaluateDecision(GatewayOuterClass.EvaluateDecisionRequest request)
      Evaluates a decision. The decision to evaluate can be specified either by
using its unique key (as returned by DeployResource), or using the decision
ID. When using the decision ID, the latest deployed version of the decision
is used.
Errors:
INVALID_ARGUMENT:
- no decision with the given key exists (if decisionKey was given)
- no decision with the given decision ID exists (if decisionId was given)
- both decision ID and decision KEY were provided, or are missing

    • deployProcess

      @Deprecated public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.DeployProcessResponse> deployProcess(GatewayOuterClass.DeployProcessRequest request)
      Deprecated.
      Deploys one or more processes to Zeebe. Note that this is an atomic call,
i.e. either all processes are deployed, or none of them are.
Errors:
INVALID_ARGUMENT:
- no resources given.
- if at least one resource is invalid. A resource is considered invalid if:
- the resource data is not deserializable (e.g. detected as BPMN, but it's broken XML)
- the process is invalid (e.g. an event-based gateway has an outgoing sequence flow to a task)

    • deployResource

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.DeployResourceResponse> deployResource(GatewayOuterClass.DeployResourceRequest request)
      Deploys one or more resources (e.g. processes or decision models) to Zeebe.
Note that this is an atomic call, i.e. either all resources are deployed, or none of them are.
Errors:
PERMISSION_DENIED:
- if a deployment to an unauthorized tenant is performed
INVALID_ARGUMENT:
- no resources given.
- if at least one resource is invalid. A resource is considered invalid if:
- the content is not deserializable (e.g. detected as BPMN, but it's broken XML)
- the content is invalid (e.g. an event-based gateway has an outgoing sequence flow to a task)
- if multi-tenancy is enabled, and:
- a tenant id is not provided
- a tenant id with an invalid format is provided
- if multi-tenancy is disabled and a tenant id is provided

    • failJob

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.FailJobResponse> failJob(GatewayOuterClass.FailJobRequest request)
      Marks the job as failed; if the retries argument is positive, then the job will be immediately
activatable again, and a worker could try again to process it. If it is zero or negative however,
an incident will be raised, tagged with the given errorMessage, and the job will not be
activatable until the incident is resolved.
Errors:
NOT_FOUND:
- no job was found with the given key
FAILED_PRECONDITION:
- the job was not activated
- the job is already in a failed state, i.e. ran out of retries

    • throwError

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.ThrowErrorResponse> throwError(GatewayOuterClass.ThrowErrorRequest request)
      Reports a business error (i.e. non-technical) that occurs while processing a job. The error is handled in the process by an error catch event. If there is no error catch event with the specified errorCode then an incident will be raised instead.
Errors:
NOT_FOUND:
- no job was found with the given key
FAILED_PRECONDITION:
- the job is not in an activated state

    • publishMessage

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.PublishMessageResponse> publishMessage(GatewayOuterClass.PublishMessageRequest request)
      Publishes a single message. Messages are published to specific partitions computed from their
correlation keys.
Errors:
ALREADY_EXISTS:
- a message with the same ID was previously published (and is still alive)

    • resolveIncident

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.ResolveIncidentResponse> resolveIncident(GatewayOuterClass.ResolveIncidentRequest request)
      Resolves a given incident. This simply marks the incident as resolved; most likely a call to
UpdateJobRetries or SetVariables will be necessary to actually resolve the
problem, following by this call.
Errors:
NOT_FOUND:
- no incident with the given key exists

    • setVariables

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.SetVariablesResponse> setVariables(GatewayOuterClass.SetVariablesRequest request)
      Updates all the variables of a particular scope (e.g. process instance, flow element instance)
from the given JSON document.
Errors:
NOT_FOUND:
- no element with the given elementInstanceKey exists
INVALID_ARGUMENT:
- the given variables document is not a valid JSON document; valid documents are expected to
be JSON documents where the root node is an object.

    • topology

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.TopologyResponse> topology(GatewayOuterClass.TopologyRequest request)
      Obtains the current topology of the cluster the gateway is part of.

    • updateJobRetries

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.UpdateJobRetriesResponse> updateJobRetries(GatewayOuterClass.UpdateJobRetriesRequest request)
      Updates the number of retries a job has left. This is mostly useful for jobs that have run out of
retries, should the underlying problem be solved.
Errors:
NOT_FOUND:
- no job exists with the given key
INVALID_ARGUMENT:
- retries is not greater than 0

    • modifyProcessInstance

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.ModifyProcessInstanceResponse> modifyProcessInstance(GatewayOuterClass.ModifyProcessInstanceRequest request)
      Modifies the process instance. This is done by activating and/or terminating specific elements of the instance.
Errors:
NOT_FOUND:
- no process instance exists with the given key
FAILED_PRECONDITION:
- trying to activate element inside of a multi-instance
INVALID_ARGUMENT:
- activating or terminating unknown element
- ancestor of element for activation doesn't exist
- scope of variable is unknown

    • deleteResource

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.DeleteResourceResponse> deleteResource(GatewayOuterClass.DeleteResourceRequest request)
      Deletes a resource from the state. Once a resource has been deleted it cannot
be recovered. If the resource needs to be available again, a new deployment
of the resource is required.
Deleting a process will cancel any running instances of this process
definition. New instances of a deleted process are created using
the lastest version that hasn't been deleted. Creating a new
process instance is impossible when all versions have been
deleted.
Deleting a decision requirement definitions could cause incidents in process
instances referencing these decisions in a business rule task. A decision
will be evaluated with the latest version that hasn't been deleted. If all
versions of a decision have been deleted the evaluation is rejected.
Errors:
NOT_FOUND:
- No resource exists with the given key

    • broadcastSignal

      public com.google.common.util.concurrent.ListenableFuture<GatewayOuterClass.BroadcastSignalResponse> broadcastSignal(GatewayOuterClass.BroadcastSignalRequest request)
      Broadcasts a signal.