def test_instantiate_workflow_template(self):
# Setup Expected Response
expected_response = {}
expected_response = empty_pb2.Empty(**expected_response)
operation = operations_pb2.Operation(
name="operations/test_instantiate_workflow_template", done=True)
operation.response.Pack(expected_response)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = dataproc_v1.WorkflowTemplateServiceClient()
# Setup Request
name = client.workflow_template_path("[PROJECT]", "[REGION]",
"[WORKFLOW_TEMPLATE]")
response = client.instantiate_workflow_template(name)
result = response.result()
assert expected_response == result
assert len(channel.requests) == 1
expected_request = workflow_templates_pb2.InstantiateWorkflowTemplateRequest(
name=name)
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def instantiate_workflow_template(
self,
name,
version=None,
request_id=None,
parameters=None,
retry=google.api_core.gapic_v1.method.DEFAULT,
timeout=google.api_core.gapic_v1.method.DEFAULT,
metadata=None,
):
"""
Instantiates a template and begins execution.
The returned Operation can be used to track execution of workflow by
polling ``operations.get``. The Operation will complete when entire
workflow is finished.
The running workflow can be aborted via ``operations.cancel``. This will
cause any inflight jobs to be cancelled and workflow-owned clusters to
be deleted.
The ``Operation.metadata`` will be
`WorkflowMetadata <https://cloud.google.com/dataproc/docs/reference/rpc/google.cloud.dataproc.v1#workflowmetadata>`__.
Also see `Using
WorkflowMetadata <https://cloud.google.com/dataproc/docs/concepts/workflows/debugging#using_workflowmetadata>`__.
On successful completion, ``Operation.response`` will be ``Empty``.
Example:
>>> from google.cloud import dataproc_v1
>>>
>>> client = dataproc_v1.WorkflowTemplateServiceClient()
>>>
>>> name = client.workflow_template_path('[PROJECT]', '[REGION]', '[WORKFLOW_TEMPLATE]')
>>>
>>> response = client.instantiate_workflow_template(name)
>>>
>>> def callback(operation_future):
... # Handle result.
... result = operation_future.result()
>>>
>>> response.add_done_callback(callback)
>>>
>>> # Handle metadata.
>>> metadata = response.metadata()
Args:
name (str): Required. The resource name of the workflow template, as described in
https://cloud.google.com/apis/design/resource\_names.
- For ``projects.regions.workflowTemplates.instantiate``, the resource
name of the template has the following format:
``projects/{project_id}/regions/{region}/workflowTemplates/{template_id}``
- For ``projects.locations.workflowTemplates.instantiate``, the
resource name of the template has the following format:
``projects/{project_id}/locations/{location}/workflowTemplates/{template_id}``
version (int): Optional. The version of workflow template to instantiate. If specified,
the workflow will be instantiated only if the current version of
the workflow template has the supplied version.
This option cannot be used to instantiate a previous version of
workflow template.
request_id (str): Optional. A tag that prevents multiple concurrent workflow instances
with the same tag from running. This mitigates risk of concurrent
instances started due to retries.
It is recommended to always set this value to a
`UUID <https://en.wikipedia.org/wiki/Universally_unique_identifier>`__.
The tag must contain only letters (a-z, A-Z), numbers (0-9), underscores
(\_), and hyphens (-). The maximum length is 40 characters.
parameters (dict[str -> str]): Optional. Map from parameter names to values that should be used for those
parameters. Values may not exceed 100 characters.
retry (Optional[google.api_core.retry.Retry]): A retry object used
to retry requests. If ``None`` is specified, requests will
be retried using a default configuration.
timeout (Optional[float]): The amount of time, in seconds, to wait
for the request to complete. Note that if ``retry`` is
specified, the timeout applies to each individual attempt.
metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata
that is provided to the method.
Returns:
A :class:`~google.cloud.dataproc_v1.types._OperationFuture` instance.
Raises:
google.api_core.exceptions.GoogleAPICallError: If the request
failed for any reason.
google.api_core.exceptions.RetryError: If the request failed due
to a retryable error and retry attempts failed.
ValueError: If the parameters are invalid.
"""
# Wrap the transport method to add retry and timeout logic.
if "instantiate_workflow_template" not in self._inner_api_calls:
self._inner_api_calls[
"instantiate_workflow_template"] = google.api_core.gapic_v1.method.wrap_method(
self.transport.instantiate_workflow_template,
default_retry=self.
_method_configs["InstantiateWorkflowTemplate"].retry,
default_timeout=self.
_method_configs["InstantiateWorkflowTemplate"].timeout,
client_info=self._client_info,
)
request = workflow_templates_pb2.InstantiateWorkflowTemplateRequest(
name=name,
version=version,
request_id=request_id,
parameters=parameters)
if metadata is None:
metadata = []
metadata = list(metadata)
try:
routing_header = [("name", name)]
except AttributeError:
pass
else:
routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata(
routing_header)
metadata.append(routing_metadata)
operation = self._inner_api_calls["instantiate_workflow_template"](
request, retry=retry, timeout=timeout, metadata=metadata)
return google.api_core.operation.from_gapic(
operation,
self.transport._operations_client,
empty_pb2.Empty,
metadata_type=workflow_templates_pb2.WorkflowMetadata,
)
