def scope_for_flow(self, flow_id: str) -> str:
"""
Returns the scope associated with a particular Flow
:param flow_id: The UUID identifying the Flow's scope to lookup
"""
flow_url = f"{self.base_url}/flows/{flow_id}"
return ActionClient.new_client(
flow_url, authorizer=self.authorizer
).action_scope
def flow_action_log(
self,
flow_id: str,
flow_scope: str,
flow_action_id: str,
limit: int = 10,
reverse_order: bool = False,
marker: Optional[str] = None,
per_page: Optional[int] = None,
**kwargs,
) -> GlobusHTTPResponse:
"""
Retrieve an Action's execution log history for an Action that was launched by a
specific Flow.
:param flow_id: The UUID identifying the Flow which launched the Action
:param flow_scope: The scope associated with the Flow ``flow_id``. If
not provided, the SDK will attempt to perform an introspection on
the Flow to pull its scope automatically
:param flow_action_id: The ID specifying the Action for which's history
to query
:param limit: An integer specifying the maximum number of records for
the Action's execution history to return.
:param reverse_order: An indicator for whether to retrieve the records
in reverse-chronological order.
:param marker: A pagination_token indicating the page of results to
return and how many entries to return. This is created by the Flow's
service and returned by operations that support pagination.
:param per_page: The number of results to return per page. If
supplied a pagination_token, this parameter has no effect.
:param kwargs: Any additional kwargs passed into this method are passed
onto the Globus BaseClient. If there exists an "authorizer" keyword
argument, that gets used to run the Flow operation. Otherwise the
authorizer_callback defined for the FlowsClient will be used.
"""
authorizer = self._get_authorizer_for_flow(flow_id, flow_scope, kwargs)
flow_url = f"{self.base_url}/flows/{flow_id}"
ac = ActionClient.new_client(flow_url, authorizer)
return ac.log(flow_action_id, limit, reverse_order, marker, per_page)
def flow_action_cancel(
self, flow_id: str, flow_scope: Optional[str], flow_action_id: str, **kwargs
) -> GlobusHTTPResponse:
"""
Cancel the excution of an Action that was launched by a Flow
:param flow_id: The UUID identifying the Flow which launched the Action
:param flow_scope: The scope associated with the Flow ``flow_id``. If
not provided, the SDK will attempt to perform an introspection on
the Flow to pull its scope automatically
:param flow_action_id: The ID specifying the Action we want to cancel
:param kwargs: Any additional kwargs passed into this method are passed
onto the Globus BaseClient. If there exists an "authorizer" keyword
argument, that gets used to run the Flow operation. Otherwise the
authorizer_callback defined for the FlowsClient will be used.
"""
authorizer = self._get_authorizer_for_flow(flow_id, flow_scope, kwargs)
flow_url = f"{self.base_url}/flows/{flow_id}"
ac = ActionClient.new_client(flow_url, authorizer)
return ac.cancel(flow_action_id)
def run_flow(
self, flow_id: str, flow_scope: Optional[str], flow_input: Mapping, **kwargs
) -> GlobusHTTPResponse:
"""
Run an instance of a deployed Flow with the given input.
:param flow_id: The UUID identifying the Flow to run
:param flow_scope: The scope associated with the Flow ``flow_id``. If
not provided, the SDK will attempt to perform an introspection on
the Flow to pull its scope automatically
:param flow_input: A Flow-specific dictionary specifying the input
required for the Flow to run.
:param kwargs: Any additional kwargs passed into this method are passed
onto the Globus BaseClient. If there exists an "authorizer" keyword
argument, that gets used to run the Flow operation. Otherwise the
authorizer_callback defined for the FlowsClient will be used.
"""
authorizer = self._get_authorizer_for_flow(flow_id, flow_scope, kwargs)
flow_url = f"{self.base_url}/flows/{flow_id}"
ac = ActionClient.new_client(flow_url, authorizer)
return ac.run(flow_input, **kwargs)
def flow_action_resume(
self, flow_id: str, flow_scope: Optional[str], flow_action_id: str, **kwargs
) -> GlobusHTTPResponse:
"""
Resume a Flow Action which is in an INACTIVE state.
:param flow_id: The UUID identifying the Flow which triggered the Action
:param flow_scope: The scope associated with the Flow ``flow_id``. If
not provided, the SDK will attempt to perform an introspection on
the Flow to determine its scope automatically.
:param flow_action_id: The ID specifying the Action with an INACTIVE
status we want to resume.
:param kwargs: Any additional kwargs passed into this method are passed
onto the Globus BaseClient. If there exists an "authorizer" keyword
argument, that gets used to run the Flow operation. Otherwise the
authorizer_callback defined for the FlowsClient will be used.
"""
authorizer = self._get_authorizer_for_flow(flow_id, flow_scope, kwargs)
flow_url = f"{self.base_url}/flows/{flow_id}"
ac = ActionClient.new_client(flow_url, authorizer)
return ac.resume(flow_action_id)
def run_flow(
self,
flow_id: str,
flow_scope: Optional[str],
flow_input: Mapping,
run_managers: Optional[Iterable[str]] = None,
run_monitors: Optional[Iterable[str]] = None,
dry_run: bool = False,
label: Optional[str] = None,
**kwargs,
) -> GlobusHTTPResponse:
"""
Run an instance of a deployed Flow with the given input.
:param flow_id: The UUID identifying the Flow to run
:param flow_scope: The scope associated with the Flow ``flow_id``. If
not provided, the SDK will attempt to perform an introspection on
the Flow to determine its scope automatically
:param flow_input: A Flow-specific dictionary specifying the input
required for the Flow to run.
:param run_managers: A series of Globus identities which may alter
this Flow instance's execution. The principal value is the user's or
group's UUID prefixed with either 'urn:globus:groups:id:' or
'urn:globus:auth:identity:'
:param run_monitors: A series of Globus identities which may view this
Flow instance's execution state. The principal value is the user's
or group's UUID prefixed with either 'urn:globus:groups:id:' or
'urn:globus:auth:identity:'
:param label: An optional label which can be used to identify this run
:param kwargs: Any additional kwargs passed into this method are passed
onto the Globus BaseClient. If there exists an "authorizer" keyword
argument, that gets used to run the Flow operation. Otherwise the
authorizer_callback defined for the FlowsClient will be used.
"""
authorizer = self._get_authorizer_for_flow(flow_id, flow_scope, kwargs)
flow_url = f"{self.base_url}/flows/{flow_id}"
ac = ActionClient.new_client(flow_url, authorizer)
run_monitors = merge_lists(run_monitors, kwargs, "monitor_by")
run_managers = merge_lists(run_managers, kwargs, "manage_by")
kwargs.pop("monitor_by", None)
kwargs.pop("manage_by", None)
if dry_run:
path = flow_url + "/dry-run"
return ac.run(
flow_input,
manage_by=run_managers,
monitor_by=run_monitors,
force_path=path,
label=label,
**kwargs,
)
else:
return ac.run(
flow_input,
manage_by=run_managers,
monitor_by=run_monitors,
label=label,
**kwargs,
)