Mercurial > repos > guerler > springsuite
comparison planemo/lib/python3.7/site-packages/boto/swf/layer1.py @ 0:d30785e31577 draft
"planemo upload commit 6eee67778febed82ddd413c3ca40b3183a3898f1"
author | guerler |
---|---|
date | Fri, 31 Jul 2020 00:18:57 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:d30785e31577 |
---|---|
1 # Copyright (c) 2012 Mitch Garnaat http://garnaat.org/ | |
2 # Copyright (c) 2012 Amazon.com, Inc. or its affiliates. | |
3 # All Rights Reserved | |
4 # | |
5 # Permission is hereby granted, free of charge, to any person obtaining a | |
6 # copy of this software and associated documentation files (the | |
7 # "Software"), to deal in the Software without restriction, including | |
8 # without limitation the rights to use, copy, modify, merge, publish, dis- | |
9 # tribute, sublicense, and/or sell copies of the Software, and to permit | |
10 # persons to whom the Software is furnished to do so, subject to the fol- | |
11 # lowing conditions: | |
12 # | |
13 # The above copyright notice and this permission notice shall be included | |
14 # in all copies or substantial portions of the Software. | |
15 # | |
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
17 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL- | |
18 # ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT | |
19 # SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, | |
20 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
22 # IN THE SOFTWARE. | |
23 # | |
24 | |
25 import time | |
26 | |
27 import boto | |
28 from boto.connection import AWSAuthConnection | |
29 from boto.provider import Provider | |
30 from boto.exception import SWFResponseError | |
31 from boto.swf import exceptions as swf_exceptions | |
32 from boto.compat import json | |
33 | |
34 # | |
35 # To get full debug output, uncomment the following line and set the | |
36 # value of Debug to be 2 | |
37 # | |
38 #boto.set_stream_logger('swf') | |
39 Debug = 0 | |
40 | |
41 | |
42 class Layer1(AWSAuthConnection): | |
43 """ | |
44 Low-level interface to Simple WorkFlow Service. | |
45 """ | |
46 | |
47 DefaultRegionName = 'us-east-1' | |
48 """The default region name for Simple Workflow.""" | |
49 | |
50 ServiceName = 'com.amazonaws.swf.service.model.SimpleWorkflowService' | |
51 """The name of the Service""" | |
52 | |
53 # In some cases, the fault response __type value is mapped to | |
54 # an exception class more specific than SWFResponseError. | |
55 _fault_excp = { | |
56 'com.amazonaws.swf.base.model#DomainAlreadyExistsFault': | |
57 swf_exceptions.SWFDomainAlreadyExistsError, | |
58 'com.amazonaws.swf.base.model#LimitExceededFault': | |
59 swf_exceptions.SWFLimitExceededError, | |
60 'com.amazonaws.swf.base.model#OperationNotPermittedFault': | |
61 swf_exceptions.SWFOperationNotPermittedError, | |
62 'com.amazonaws.swf.base.model#TypeAlreadyExistsFault': | |
63 swf_exceptions.SWFTypeAlreadyExistsError, | |
64 'com.amazonaws.swf.base.model#WorkflowExecutionAlreadyStartedFault': | |
65 swf_exceptions.SWFWorkflowExecutionAlreadyStartedError, | |
66 } | |
67 | |
68 ResponseError = SWFResponseError | |
69 | |
70 def __init__(self, aws_access_key_id=None, aws_secret_access_key=None, | |
71 is_secure=True, port=None, proxy=None, proxy_port=None, | |
72 debug=0, session_token=None, region=None, profile_name=None): | |
73 if not region: | |
74 region_name = boto.config.get('SWF', 'region', | |
75 self.DefaultRegionName) | |
76 for reg in boto.swf.regions(): | |
77 if reg.name == region_name: | |
78 region = reg | |
79 break | |
80 | |
81 self.region = region | |
82 super(Layer1, self).__init__(self.region.endpoint, | |
83 aws_access_key_id, aws_secret_access_key, | |
84 is_secure, port, proxy, proxy_port, | |
85 debug, session_token, profile_name=profile_name) | |
86 | |
87 def _required_auth_capability(self): | |
88 return ['hmac-v4'] | |
89 | |
90 @classmethod | |
91 def _normalize_request_dict(cls, data): | |
92 """ | |
93 This class method recurses through request data dictionary and removes | |
94 any default values. | |
95 | |
96 :type data: dict | |
97 :param data: Specifies request parameters with default values to be removed. | |
98 """ | |
99 for item in list(data.keys()): | |
100 if isinstance(data[item], dict): | |
101 cls._normalize_request_dict(data[item]) | |
102 if data[item] in (None, {}): | |
103 del data[item] | |
104 | |
105 def json_request(self, action, data, object_hook=None): | |
106 """ | |
107 This method wraps around make_request() to normalize and serialize the | |
108 dictionary with request parameters. | |
109 | |
110 :type action: string | |
111 :param action: Specifies an SWF action. | |
112 | |
113 :type data: dict | |
114 :param data: Specifies request parameters associated with the action. | |
115 """ | |
116 self._normalize_request_dict(data) | |
117 json_input = json.dumps(data) | |
118 return self.make_request(action, json_input, object_hook) | |
119 | |
120 def make_request(self, action, body='', object_hook=None): | |
121 """ | |
122 :raises: ``SWFResponseError`` if response status is not 200. | |
123 """ | |
124 headers = {'X-Amz-Target': '%s.%s' % (self.ServiceName, action), | |
125 'Host': self.region.endpoint, | |
126 'Content-Type': 'application/json; charset=UTF-8', | |
127 'Content-Encoding': 'amz-1.0', | |
128 'Content-Length': str(len(body))} | |
129 http_request = self.build_base_http_request('POST', '/', '/', | |
130 {}, headers, body, None) | |
131 response = self._mexe(http_request, sender=None, | |
132 override_num_retries=10) | |
133 response_body = response.read().decode('utf-8') | |
134 boto.log.debug(response_body) | |
135 if response.status == 200: | |
136 if response_body: | |
137 return json.loads(response_body, object_hook=object_hook) | |
138 else: | |
139 return None | |
140 else: | |
141 json_body = json.loads(response_body) | |
142 fault_name = json_body.get('__type', None) | |
143 # Certain faults get mapped to more specific exception classes. | |
144 excp_cls = self._fault_excp.get(fault_name, self.ResponseError) | |
145 raise excp_cls(response.status, response.reason, body=json_body) | |
146 | |
147 # Actions related to Activities | |
148 | |
149 def poll_for_activity_task(self, domain, task_list, identity=None): | |
150 """ | |
151 Used by workers to get an ActivityTask from the specified | |
152 activity taskList. This initiates a long poll, where the | |
153 service holds the HTTP connection open and responds as soon as | |
154 a task becomes available. The maximum time the service holds | |
155 on to the request before responding is 60 seconds. If no task | |
156 is available within 60 seconds, the poll will return an empty | |
157 result. An empty result, in this context, means that an | |
158 ActivityTask is returned, but that the value of taskToken is | |
159 an empty string. If a task is returned, the worker should use | |
160 its type to identify and process it correctly. | |
161 | |
162 :type domain: string | |
163 :param domain: The name of the domain that contains the task | |
164 lists being polled. | |
165 | |
166 :type task_list: string | |
167 :param task_list: Specifies the task list to poll for activity tasks. | |
168 | |
169 :type identity: string | |
170 :param identity: Identity of the worker making the request, which | |
171 is recorded in the ActivityTaskStarted event in the workflow | |
172 history. This enables diagnostic tracing when problems arise. | |
173 The form of this identity is user defined. | |
174 | |
175 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
176 """ | |
177 return self.json_request('PollForActivityTask', { | |
178 'domain': domain, | |
179 'taskList': {'name': task_list}, | |
180 'identity': identity, | |
181 }) | |
182 | |
183 def respond_activity_task_completed(self, task_token, result=None): | |
184 """ | |
185 Used by workers to tell the service that the ActivityTask | |
186 identified by the taskToken completed successfully with a | |
187 result (if provided). | |
188 | |
189 :type task_token: string | |
190 :param task_token: The taskToken of the ActivityTask. | |
191 | |
192 :type result: string | |
193 :param result: The result of the activity task. It is a free | |
194 form string that is implementation specific. | |
195 | |
196 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
197 """ | |
198 return self.json_request('RespondActivityTaskCompleted', { | |
199 'taskToken': task_token, | |
200 'result': result, | |
201 }) | |
202 | |
203 def respond_activity_task_failed(self, task_token, | |
204 details=None, reason=None): | |
205 """ | |
206 Used by workers to tell the service that the ActivityTask | |
207 identified by the taskToken has failed with reason (if | |
208 specified). | |
209 | |
210 :type task_token: string | |
211 :param task_token: The taskToken of the ActivityTask. | |
212 | |
213 :type details: string | |
214 :param details: Optional detailed information about the failure. | |
215 | |
216 :type reason: string | |
217 :param reason: Description of the error that may assist in diagnostics. | |
218 | |
219 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
220 """ | |
221 return self.json_request('RespondActivityTaskFailed', { | |
222 'taskToken': task_token, | |
223 'details': details, | |
224 'reason': reason, | |
225 }) | |
226 | |
227 def respond_activity_task_canceled(self, task_token, details=None): | |
228 """ | |
229 Used by workers to tell the service that the ActivityTask | |
230 identified by the taskToken was successfully | |
231 canceled. Additional details can be optionally provided using | |
232 the details argument. | |
233 | |
234 :type task_token: string | |
235 :param task_token: The taskToken of the ActivityTask. | |
236 | |
237 :type details: string | |
238 :param details: Optional detailed information about the failure. | |
239 | |
240 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
241 """ | |
242 return self.json_request('RespondActivityTaskCanceled', { | |
243 'taskToken': task_token, | |
244 'details': details, | |
245 }) | |
246 | |
247 def record_activity_task_heartbeat(self, task_token, details=None): | |
248 """ | |
249 Used by activity workers to report to the service that the | |
250 ActivityTask represented by the specified taskToken is still | |
251 making progress. The worker can also (optionally) specify | |
252 details of the progress, for example percent complete, using | |
253 the details parameter. This action can also be used by the | |
254 worker as a mechanism to check if cancellation is being | |
255 requested for the activity task. If a cancellation is being | |
256 attempted for the specified task, then the boolean | |
257 cancelRequested flag returned by the service is set to true. | |
258 | |
259 :type task_token: string | |
260 :param task_token: The taskToken of the ActivityTask. | |
261 | |
262 :type details: string | |
263 :param details: If specified, contains details about the | |
264 progress of the task. | |
265 | |
266 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
267 """ | |
268 return self.json_request('RecordActivityTaskHeartbeat', { | |
269 'taskToken': task_token, | |
270 'details': details, | |
271 }) | |
272 | |
273 # Actions related to Deciders | |
274 | |
275 def poll_for_decision_task(self, domain, task_list, identity=None, | |
276 maximum_page_size=None, | |
277 next_page_token=None, | |
278 reverse_order=None): | |
279 """ | |
280 Used by deciders to get a DecisionTask from the specified | |
281 decision taskList. A decision task may be returned for any | |
282 open workflow execution that is using the specified task | |
283 list. The task includes a paginated view of the history of the | |
284 workflow execution. The decider should use the workflow type | |
285 and the history to determine how to properly handle the task. | |
286 | |
287 :type domain: string | |
288 :param domain: The name of the domain containing the task | |
289 lists to poll. | |
290 | |
291 :type task_list: string | |
292 :param task_list: Specifies the task list to poll for decision tasks. | |
293 | |
294 :type identity: string | |
295 :param identity: Identity of the decider making the request, | |
296 which is recorded in the DecisionTaskStarted event in the | |
297 workflow history. This enables diagnostic tracing when | |
298 problems arise. The form of this identity is user defined. | |
299 | |
300 :type maximum_page_size: integer :param maximum_page_size: The | |
301 maximum number of history events returned in each page. The | |
302 default is 100, but the caller can override this value to a | |
303 page size smaller than the default. You cannot specify a page | |
304 size greater than 100. | |
305 | |
306 :type next_page_token: string | |
307 :param next_page_token: If on a previous call to this method a | |
308 NextPageToken was returned, the results are being paginated. | |
309 To get the next page of results, repeat the call with the | |
310 returned token and all other arguments unchanged. | |
311 | |
312 :type reverse_order: boolean | |
313 :param reverse_order: When set to true, returns the events in | |
314 reverse order. By default the results are returned in | |
315 ascending order of the eventTimestamp of the events. | |
316 | |
317 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
318 """ | |
319 return self.json_request('PollForDecisionTask', { | |
320 'domain': domain, | |
321 'taskList': {'name': task_list}, | |
322 'identity': identity, | |
323 'maximumPageSize': maximum_page_size, | |
324 'nextPageToken': next_page_token, | |
325 'reverseOrder': reverse_order, | |
326 }) | |
327 | |
328 def respond_decision_task_completed(self, task_token, | |
329 decisions=None, | |
330 execution_context=None): | |
331 """ | |
332 Used by deciders to tell the service that the DecisionTask | |
333 identified by the taskToken has successfully completed. | |
334 The decisions argument specifies the list of decisions | |
335 made while processing the task. | |
336 | |
337 :type task_token: string | |
338 :param task_token: The taskToken of the ActivityTask. | |
339 | |
340 :type decisions: list | |
341 :param decisions: The list of decisions (possibly empty) made by | |
342 the decider while processing this decision task. See the docs | |
343 for the Decision structure for details. | |
344 | |
345 :type execution_context: string | |
346 :param execution_context: User defined context to add to | |
347 workflow execution. | |
348 | |
349 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
350 """ | |
351 return self.json_request('RespondDecisionTaskCompleted', { | |
352 'taskToken': task_token, | |
353 'decisions': decisions, | |
354 'executionContext': execution_context, | |
355 }) | |
356 | |
357 def request_cancel_workflow_execution(self, domain, workflow_id, | |
358 run_id=None): | |
359 """ | |
360 Records a WorkflowExecutionCancelRequested event in the | |
361 currently running workflow execution identified by the given | |
362 domain, workflowId, and runId. This logically requests the | |
363 cancellation of the workflow execution as a whole. It is up to | |
364 the decider to take appropriate actions when it receives an | |
365 execution history with this event. | |
366 | |
367 :type domain: string | |
368 :param domain: The name of the domain containing the workflow | |
369 execution to cancel. | |
370 | |
371 :type run_id: string | |
372 :param run_id: The runId of the workflow execution to cancel. | |
373 | |
374 :type workflow_id: string | |
375 :param workflow_id: The workflowId of the workflow execution | |
376 to cancel. | |
377 | |
378 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
379 """ | |
380 return self.json_request('RequestCancelWorkflowExecution', { | |
381 'domain': domain, | |
382 'workflowId': workflow_id, | |
383 'runId': run_id, | |
384 }) | |
385 | |
386 def start_workflow_execution(self, domain, workflow_id, | |
387 workflow_name, workflow_version, | |
388 task_list=None, child_policy=None, | |
389 execution_start_to_close_timeout=None, | |
390 input=None, tag_list=None, | |
391 task_start_to_close_timeout=None): | |
392 """ | |
393 Starts an execution of the workflow type in the specified | |
394 domain using the provided workflowId and input data. | |
395 | |
396 :type domain: string | |
397 :param domain: The name of the domain in which the workflow | |
398 execution is created. | |
399 | |
400 :type workflow_id: string | |
401 :param workflow_id: The user defined identifier associated with | |
402 the workflow execution. You can use this to associate a | |
403 custom identifier with the workflow execution. You may | |
404 specify the same identifier if a workflow execution is | |
405 logically a restart of a previous execution. You cannot | |
406 have two open workflow executions with the same workflowId | |
407 at the same time. | |
408 | |
409 :type workflow_name: string | |
410 :param workflow_name: The name of the workflow type. | |
411 | |
412 :type workflow_version: string | |
413 :param workflow_version: The version of the workflow type. | |
414 | |
415 :type task_list: string | |
416 :param task_list: The task list to use for the decision tasks | |
417 generated for this workflow execution. This overrides the | |
418 defaultTaskList specified when registering the workflow type. | |
419 | |
420 :type child_policy: string | |
421 :param child_policy: If set, specifies the policy to use for the | |
422 child workflow executions of this workflow execution if it | |
423 is terminated, by calling the TerminateWorkflowExecution | |
424 action explicitly or due to an expired timeout. This policy | |
425 overrides the default child policy specified when registering | |
426 the workflow type using RegisterWorkflowType. The supported | |
427 child policies are: | |
428 | |
429 * TERMINATE: the child executions will be terminated. | |
430 * REQUEST_CANCEL: a request to cancel will be attempted | |
431 for each child execution by recording a | |
432 WorkflowExecutionCancelRequested event in its history. | |
433 It is up to the decider to take appropriate actions | |
434 when it receives an execution history with this event. | |
435 * ABANDON: no action will be taken. The child executions | |
436 will continue to run. | |
437 | |
438 :type execution_start_to_close_timeout: string | |
439 :param execution_start_to_close_timeout: The total duration for | |
440 this workflow execution. This overrides the | |
441 defaultExecutionStartToCloseTimeout specified when | |
442 registering the workflow type. | |
443 | |
444 :type input: string | |
445 :param input: The input for the workflow | |
446 execution. This is a free form string which should be | |
447 meaningful to the workflow you are starting. This input is | |
448 made available to the new workflow execution in the | |
449 WorkflowExecutionStarted history event. | |
450 | |
451 :type tag_list: list :param tag_list: The list of tags to | |
452 associate with the workflow execution. You can specify a | |
453 maximum of 5 tags. You can list workflow executions with a | |
454 specific tag by calling list_open_workflow_executions or | |
455 list_closed_workflow_executions and specifying a TagFilter. | |
456 | |
457 :type task_start_to_close_timeout: string :param | |
458 task_start_to_close_timeout: Specifies the maximum duration of | |
459 decision tasks for this workflow execution. This parameter | |
460 overrides the defaultTaskStartToCloseTimout specified when | |
461 registering the workflow type using register_workflow_type. | |
462 | |
463 :raises: UnknownResourceFault, TypeDeprecatedFault, | |
464 SWFWorkflowExecutionAlreadyStartedError, SWFLimitExceededError, | |
465 SWFOperationNotPermittedError, DefaultUndefinedFault | |
466 """ | |
467 return self.json_request('StartWorkflowExecution', { | |
468 'domain': domain, | |
469 'workflowId': workflow_id, | |
470 'workflowType': {'name': workflow_name, | |
471 'version': workflow_version}, | |
472 'taskList': {'name': task_list}, | |
473 'childPolicy': child_policy, | |
474 'executionStartToCloseTimeout': execution_start_to_close_timeout, | |
475 'input': input, | |
476 'tagList': tag_list, | |
477 'taskStartToCloseTimeout': task_start_to_close_timeout, | |
478 | |
479 }) | |
480 | |
481 def signal_workflow_execution(self, domain, signal_name, workflow_id, | |
482 input=None, run_id=None): | |
483 """ | |
484 Records a WorkflowExecutionSignaled event in the workflow | |
485 execution history and creates a decision task for the workflow | |
486 execution identified by the given domain, workflowId and | |
487 runId. The event is recorded with the specified user defined | |
488 signalName and input (if provided). | |
489 | |
490 :type domain: string | |
491 :param domain: The name of the domain containing the workflow | |
492 execution to signal. | |
493 | |
494 :type signal_name: string | |
495 :param signal_name: The name of the signal. This name must be | |
496 meaningful to the target workflow. | |
497 | |
498 :type workflow_id: string | |
499 :param workflow_id: The workflowId of the workflow execution | |
500 to signal. | |
501 | |
502 :type input: string | |
503 :param input: Data to attach to the WorkflowExecutionSignaled | |
504 event in the target workflow execution's history. | |
505 | |
506 :type run_id: string | |
507 :param run_id: The runId of the workflow execution to signal. | |
508 | |
509 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
510 """ | |
511 return self.json_request('SignalWorkflowExecution', { | |
512 'domain': domain, | |
513 'signalName': signal_name, | |
514 'workflowId': workflow_id, | |
515 'input': input, | |
516 'runId': run_id, | |
517 }) | |
518 | |
519 def terminate_workflow_execution(self, domain, workflow_id, | |
520 child_policy=None, details=None, | |
521 reason=None, run_id=None): | |
522 """ | |
523 Records a WorkflowExecutionTerminated event and forces closure | |
524 of the workflow execution identified by the given domain, | |
525 runId, and workflowId. The child policy, registered with the | |
526 workflow type or specified when starting this execution, is | |
527 applied to any open child workflow executions of this workflow | |
528 execution. | |
529 | |
530 :type domain: string | |
531 :param domain: The domain of the workflow execution to terminate. | |
532 | |
533 :type workflow_id: string | |
534 :param workflow_id: The workflowId of the workflow execution | |
535 to terminate. | |
536 | |
537 :type child_policy: string | |
538 :param child_policy: If set, specifies the policy to use for | |
539 the child workflow executions of the workflow execution being | |
540 terminated. This policy overrides the child policy specified | |
541 for the workflow execution at registration time or when | |
542 starting the execution. The supported child policies are: | |
543 | |
544 * TERMINATE: the child executions will be terminated. | |
545 | |
546 * REQUEST_CANCEL: a request to cancel will be attempted | |
547 for each child execution by recording a | |
548 WorkflowExecutionCancelRequested event in its | |
549 history. It is up to the decider to take appropriate | |
550 actions when it receives an execution history with this | |
551 event. | |
552 | |
553 * ABANDON: no action will be taken. The child executions | |
554 will continue to run. | |
555 | |
556 :type details: string | |
557 :param details: Optional details for terminating the | |
558 workflow execution. | |
559 | |
560 :type reason: string | |
561 :param reason: An optional descriptive reason for terminating | |
562 the workflow execution. | |
563 | |
564 :type run_id: string | |
565 :param run_id: The runId of the workflow execution to terminate. | |
566 | |
567 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
568 """ | |
569 return self.json_request('TerminateWorkflowExecution', { | |
570 'domain': domain, | |
571 'workflowId': workflow_id, | |
572 'childPolicy': child_policy, | |
573 'details': details, | |
574 'reason': reason, | |
575 'runId': run_id, | |
576 }) | |
577 | |
578 # Actions related to Administration | |
579 | |
580 ## Activity Management | |
581 | |
582 def register_activity_type(self, domain, name, version, task_list=None, | |
583 default_task_heartbeat_timeout=None, | |
584 default_task_schedule_to_close_timeout=None, | |
585 default_task_schedule_to_start_timeout=None, | |
586 default_task_start_to_close_timeout=None, | |
587 description=None): | |
588 """ | |
589 Registers a new activity type along with its configuration | |
590 settings in the specified domain. | |
591 | |
592 :type domain: string | |
593 :param domain: The name of the domain in which this activity is | |
594 to be registered. | |
595 | |
596 :type name: string | |
597 :param name: The name of the activity type within the domain. | |
598 | |
599 :type version: string | |
600 :param version: The version of the activity type. | |
601 | |
602 :type task_list: string | |
603 :param task_list: If set, specifies the default task list to | |
604 use for scheduling tasks of this activity type. This default | |
605 task list is used if a task list is not provided when a task | |
606 is scheduled through the schedule_activity_task Decision. | |
607 | |
608 :type default_task_heartbeat_timeout: string | |
609 :param default_task_heartbeat_timeout: If set, specifies the | |
610 default maximum time before which a worker processing a task | |
611 of this type must report progress by calling | |
612 RecordActivityTaskHeartbeat. If the timeout is exceeded, the | |
613 activity task is automatically timed out. This default can be | |
614 overridden when scheduling an activity task using the | |
615 ScheduleActivityTask Decision. If the activity worker | |
616 subsequently attempts to record a heartbeat or returns a | |
617 result, the activity worker receives an UnknownResource | |
618 fault. In this case, Amazon SWF no longer considers the | |
619 activity task to be valid; the activity worker should clean up | |
620 the activity task.no docs | |
621 | |
622 :type default_task_schedule_to_close_timeout: string | |
623 :param default_task_schedule_to_close_timeout: If set, | |
624 specifies the default maximum duration for a task of this | |
625 activity type. This default can be overridden when scheduling | |
626 an activity task using the ScheduleActivityTask Decision.no | |
627 docs | |
628 | |
629 :type default_task_schedule_to_start_timeout: string | |
630 :param default_task_schedule_to_start_timeout: If set, | |
631 specifies the default maximum duration that a task of this | |
632 activity type can wait before being assigned to a worker. This | |
633 default can be overridden when scheduling an activity task | |
634 using the ScheduleActivityTask Decision. | |
635 | |
636 :type default_task_start_to_close_timeout: string | |
637 :param default_task_start_to_close_timeout: If set, specifies | |
638 the default maximum duration that a worker can take to process | |
639 tasks of this activity type. This default can be overridden | |
640 when scheduling an activity task using the | |
641 ScheduleActivityTask Decision. | |
642 | |
643 :type description: string | |
644 :param description: A textual description of the activity type. | |
645 | |
646 :raises: SWFTypeAlreadyExistsError, SWFLimitExceededError, | |
647 UnknownResourceFault, SWFOperationNotPermittedError | |
648 """ | |
649 return self.json_request('RegisterActivityType', { | |
650 'domain': domain, | |
651 'name': name, | |
652 'version': version, | |
653 'defaultTaskList': {'name': task_list}, | |
654 'defaultTaskHeartbeatTimeout': default_task_heartbeat_timeout, | |
655 'defaultTaskScheduleToCloseTimeout': default_task_schedule_to_close_timeout, | |
656 'defaultTaskScheduleToStartTimeout': default_task_schedule_to_start_timeout, | |
657 'defaultTaskStartToCloseTimeout': default_task_start_to_close_timeout, | |
658 'description': description, | |
659 }) | |
660 | |
661 def deprecate_activity_type(self, domain, activity_name, activity_version): | |
662 """ | |
663 Deprecates the specified activity type. After an activity | |
664 type has been deprecated, you cannot create new tasks of | |
665 that activity type. Tasks of this type that were scheduled | |
666 before the type was deprecated will continue to run. | |
667 | |
668 :type domain: string | |
669 :param domain: The name of the domain in which the activity | |
670 type is registered. | |
671 | |
672 :type activity_name: string | |
673 :param activity_name: The name of this activity. | |
674 | |
675 :type activity_version: string | |
676 :param activity_version: The version of this activity. | |
677 | |
678 :raises: UnknownResourceFault, TypeDeprecatedFault, | |
679 SWFOperationNotPermittedError | |
680 """ | |
681 return self.json_request('DeprecateActivityType', { | |
682 'domain': domain, | |
683 'activityType': {'name': activity_name, | |
684 'version': activity_version} | |
685 }) | |
686 | |
687 ## Workflow Management | |
688 | |
689 def register_workflow_type(self, domain, name, version, | |
690 task_list=None, | |
691 default_child_policy=None, | |
692 default_execution_start_to_close_timeout=None, | |
693 default_task_start_to_close_timeout=None, | |
694 description=None): | |
695 """ | |
696 Registers a new workflow type and its configuration settings | |
697 in the specified domain. | |
698 | |
699 :type domain: string | |
700 :param domain: The name of the domain in which to register | |
701 the workflow type. | |
702 | |
703 :type name: string | |
704 :param name: The name of the workflow type. | |
705 | |
706 :type version: string | |
707 :param version: The version of the workflow type. | |
708 | |
709 :type task_list: list of name, version of tasks | |
710 :param task_list: If set, specifies the default task list to use | |
711 for scheduling decision tasks for executions of this workflow | |
712 type. This default is used only if a task list is not provided | |
713 when starting the execution through the StartWorkflowExecution | |
714 Action or StartChildWorkflowExecution Decision. | |
715 | |
716 :type default_child_policy: string | |
717 | |
718 :param default_child_policy: If set, specifies the default | |
719 policy to use for the child workflow executions when a | |
720 workflow execution of this type is terminated, by calling the | |
721 TerminateWorkflowExecution action explicitly or due to an | |
722 expired timeout. This default can be overridden when starting | |
723 a workflow execution using the StartWorkflowExecution action | |
724 or the StartChildWorkflowExecution Decision. The supported | |
725 child policies are: | |
726 | |
727 * TERMINATE: the child executions will be terminated. | |
728 | |
729 * REQUEST_CANCEL: a request to cancel will be attempted | |
730 for each child execution by recording a | |
731 WorkflowExecutionCancelRequested event in its | |
732 history. It is up to the decider to take appropriate | |
733 actions when it receives an execution history with this | |
734 event. | |
735 | |
736 * ABANDON: no action will be taken. The child executions | |
737 will continue to run.no docs | |
738 | |
739 :type default_execution_start_to_close_timeout: string | |
740 :param default_execution_start_to_close_timeout: If set, | |
741 specifies the default maximum duration for executions of this | |
742 workflow type. You can override this default when starting an | |
743 execution through the StartWorkflowExecution Action or | |
744 StartChildWorkflowExecution Decision. | |
745 | |
746 :type default_task_start_to_close_timeout: string | |
747 :param default_task_start_to_close_timeout: If set, specifies | |
748 the default maximum duration of decision tasks for this | |
749 workflow type. This default can be overridden when starting a | |
750 workflow execution using the StartWorkflowExecution action or | |
751 the StartChildWorkflowExecution Decision. | |
752 | |
753 :type description: string | |
754 :param description: Textual description of the workflow type. | |
755 | |
756 :raises: SWFTypeAlreadyExistsError, SWFLimitExceededError, | |
757 UnknownResourceFault, SWFOperationNotPermittedError | |
758 """ | |
759 return self.json_request('RegisterWorkflowType', { | |
760 'domain': domain, | |
761 'name': name, | |
762 'version': version, | |
763 'defaultTaskList': {'name': task_list}, | |
764 'defaultChildPolicy': default_child_policy, | |
765 'defaultExecutionStartToCloseTimeout': default_execution_start_to_close_timeout, | |
766 'defaultTaskStartToCloseTimeout': default_task_start_to_close_timeout, | |
767 'description': description, | |
768 }) | |
769 | |
770 def deprecate_workflow_type(self, domain, workflow_name, workflow_version): | |
771 """ | |
772 Deprecates the specified workflow type. After a workflow type | |
773 has been deprecated, you cannot create new executions of that | |
774 type. Executions that were started before the type was | |
775 deprecated will continue to run. A deprecated workflow type | |
776 may still be used when calling visibility actions. | |
777 | |
778 :type domain: string | |
779 :param domain: The name of the domain in which the workflow | |
780 type is registered. | |
781 | |
782 :type workflow_name: string | |
783 :param workflow_name: The name of the workflow type. | |
784 | |
785 :type workflow_version: string | |
786 :param workflow_version: The version of the workflow type. | |
787 | |
788 :raises: UnknownResourceFault, TypeDeprecatedFault, | |
789 SWFOperationNotPermittedError | |
790 """ | |
791 return self.json_request('DeprecateWorkflowType', { | |
792 'domain': domain, | |
793 'workflowType': {'name': workflow_name, | |
794 'version': workflow_version}, | |
795 }) | |
796 | |
797 ## Domain Management | |
798 | |
799 def register_domain(self, name, | |
800 workflow_execution_retention_period_in_days, | |
801 description=None): | |
802 """ | |
803 Registers a new domain. | |
804 | |
805 :type name: string | |
806 :param name: Name of the domain to register. The name must be unique. | |
807 | |
808 :type workflow_execution_retention_period_in_days: string | |
809 | |
810 :param workflow_execution_retention_period_in_days: Specifies | |
811 the duration *in days* for which the record (including the | |
812 history) of workflow executions in this domain should be kept | |
813 by the service. After the retention period, the workflow | |
814 execution will not be available in the results of visibility | |
815 calls. If a duration of NONE is specified, the records for | |
816 workflow executions in this domain are not retained at all. | |
817 | |
818 :type description: string | |
819 :param description: Textual description of the domain. | |
820 | |
821 :raises: SWFDomainAlreadyExistsError, SWFLimitExceededError, | |
822 SWFOperationNotPermittedError | |
823 """ | |
824 return self.json_request('RegisterDomain', { | |
825 'name': name, | |
826 'workflowExecutionRetentionPeriodInDays': workflow_execution_retention_period_in_days, | |
827 'description': description, | |
828 }) | |
829 | |
830 def deprecate_domain(self, name): | |
831 """ | |
832 Deprecates the specified domain. After a domain has been | |
833 deprecated it cannot be used to create new workflow executions | |
834 or register new types. However, you can still use visibility | |
835 actions on this domain. Deprecating a domain also deprecates | |
836 all activity and workflow types registered in the | |
837 domain. Executions that were started before the domain was | |
838 deprecated will continue to run. | |
839 | |
840 :type name: string | |
841 :param name: The name of the domain to deprecate. | |
842 | |
843 :raises: UnknownResourceFault, DomainDeprecatedFault, | |
844 SWFOperationNotPermittedError | |
845 """ | |
846 return self.json_request('DeprecateDomain', {'name': name}) | |
847 | |
848 # Visibility Actions | |
849 | |
850 ## Activity Visibility | |
851 | |
852 def list_activity_types(self, domain, registration_status, | |
853 name=None, | |
854 maximum_page_size=None, | |
855 next_page_token=None, reverse_order=None): | |
856 """ | |
857 Returns information about all activities registered in the | |
858 specified domain that match the specified name and | |
859 registration status. The result includes information like | |
860 creation date, current status of the activity, etc. The | |
861 results may be split into multiple pages. To retrieve | |
862 subsequent pages, make the call again using the nextPageToken | |
863 returned by the initial call. | |
864 | |
865 :type domain: string | |
866 :param domain: The name of the domain in which the activity | |
867 types have been registered. | |
868 | |
869 :type registration_status: string | |
870 :param registration_status: Specifies the registration status | |
871 of the activity types to list. Valid values are: | |
872 | |
873 * REGISTERED | |
874 * DEPRECATED | |
875 | |
876 :type name: string | |
877 :param name: If specified, only lists the activity types that | |
878 have this name. | |
879 | |
880 :type maximum_page_size: integer | |
881 :param maximum_page_size: The maximum number of results | |
882 returned in each page. The default is 100, but the caller can | |
883 override this value to a page size smaller than the | |
884 default. You cannot specify a page size greater than 100. | |
885 | |
886 :type next_page_token: string | |
887 :param next_page_token: If on a previous call to this method a | |
888 NextResultToken was returned, the results have more than one | |
889 page. To get the next page of results, repeat the call with | |
890 the nextPageToken and keep all other arguments unchanged. | |
891 | |
892 :type reverse_order: boolean | |
893 | |
894 :param reverse_order: When set to true, returns the results in | |
895 reverse order. By default the results are returned in | |
896 ascending alphabetical order of the name of the activity | |
897 types. | |
898 | |
899 :raises: SWFOperationNotPermittedError, UnknownResourceFault | |
900 """ | |
901 return self.json_request('ListActivityTypes', { | |
902 'domain': domain, | |
903 'name': name, | |
904 'registrationStatus': registration_status, | |
905 'maximumPageSize': maximum_page_size, | |
906 'nextPageToken': next_page_token, | |
907 'reverseOrder': reverse_order, | |
908 }) | |
909 | |
910 def describe_activity_type(self, domain, activity_name, activity_version): | |
911 """ | |
912 Returns information about the specified activity type. This | |
913 includes configuration settings provided at registration time | |
914 as well as other general information about the type. | |
915 | |
916 :type domain: string | |
917 :param domain: The name of the domain in which the activity | |
918 type is registered. | |
919 | |
920 :type activity_name: string | |
921 :param activity_name: The name of this activity. | |
922 | |
923 :type activity_version: string | |
924 :param activity_version: The version of this activity. | |
925 | |
926 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
927 """ | |
928 return self.json_request('DescribeActivityType', { | |
929 'domain': domain, | |
930 'activityType': {'name': activity_name, | |
931 'version': activity_version} | |
932 }) | |
933 | |
934 ## Workflow Visibility | |
935 | |
936 def list_workflow_types(self, domain, registration_status, | |
937 maximum_page_size=None, name=None, | |
938 next_page_token=None, reverse_order=None): | |
939 """ | |
940 Returns information about workflow types in the specified | |
941 domain. The results may be split into multiple pages that can | |
942 be retrieved by making the call repeatedly. | |
943 | |
944 :type domain: string | |
945 :param domain: The name of the domain in which the workflow | |
946 types have been registered. | |
947 | |
948 :type registration_status: string | |
949 :param registration_status: Specifies the registration status | |
950 of the activity types to list. Valid values are: | |
951 | |
952 * REGISTERED | |
953 * DEPRECATED | |
954 | |
955 :type name: string | |
956 :param name: If specified, lists the workflow type with this name. | |
957 | |
958 :type maximum_page_size: integer | |
959 :param maximum_page_size: The maximum number of results | |
960 returned in each page. The default is 100, but the caller can | |
961 override this value to a page size smaller than the | |
962 default. You cannot specify a page size greater than 100. | |
963 | |
964 :type next_page_token: string | |
965 :param next_page_token: If on a previous call to this method a | |
966 NextPageToken was returned, the results are being | |
967 paginated. To get the next page of results, repeat the call | |
968 with the returned token and all other arguments unchanged. | |
969 | |
970 :type reverse_order: boolean | |
971 :param reverse_order: When set to true, returns the results in | |
972 reverse order. By default the results are returned in | |
973 ascending alphabetical order of the name of the workflow | |
974 types. | |
975 | |
976 :raises: SWFOperationNotPermittedError, UnknownResourceFault | |
977 """ | |
978 return self.json_request('ListWorkflowTypes', { | |
979 'domain': domain, | |
980 'name': name, | |
981 'registrationStatus': registration_status, | |
982 'maximumPageSize': maximum_page_size, | |
983 'nextPageToken': next_page_token, | |
984 'reverseOrder': reverse_order, | |
985 }) | |
986 | |
987 def describe_workflow_type(self, domain, workflow_name, workflow_version): | |
988 """ | |
989 Returns information about the specified workflow type. This | |
990 includes configuration settings specified when the type was | |
991 registered and other information such as creation date, | |
992 current status, etc. | |
993 | |
994 :type domain: string | |
995 :param domain: The name of the domain in which this workflow | |
996 type is registered. | |
997 | |
998 :type workflow_name: string | |
999 :param workflow_name: The name of the workflow type. | |
1000 | |
1001 :type workflow_version: string | |
1002 :param workflow_version: The version of the workflow type. | |
1003 | |
1004 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1005 """ | |
1006 return self.json_request('DescribeWorkflowType', { | |
1007 'domain': domain, | |
1008 'workflowType': {'name': workflow_name, | |
1009 'version': workflow_version} | |
1010 }) | |
1011 | |
1012 ## Workflow Execution Visibility | |
1013 | |
1014 def describe_workflow_execution(self, domain, run_id, workflow_id): | |
1015 """ | |
1016 Returns information about the specified workflow execution | |
1017 including its type and some statistics. | |
1018 | |
1019 :type domain: string | |
1020 :param domain: The name of the domain containing the | |
1021 workflow execution. | |
1022 | |
1023 :type run_id: string | |
1024 :param run_id: A system generated unique identifier for the | |
1025 workflow execution. | |
1026 | |
1027 :type workflow_id: string | |
1028 :param workflow_id: The user defined identifier associated | |
1029 with the workflow execution. | |
1030 | |
1031 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1032 """ | |
1033 return self.json_request('DescribeWorkflowExecution', { | |
1034 'domain': domain, | |
1035 'execution': {'runId': run_id, | |
1036 'workflowId': workflow_id}, | |
1037 }) | |
1038 | |
1039 def get_workflow_execution_history(self, domain, run_id, workflow_id, | |
1040 maximum_page_size=None, | |
1041 next_page_token=None, | |
1042 reverse_order=None): | |
1043 """ | |
1044 Returns the history of the specified workflow execution. The | |
1045 results may be split into multiple pages. To retrieve | |
1046 subsequent pages, make the call again using the nextPageToken | |
1047 returned by the initial call. | |
1048 | |
1049 :type domain: string | |
1050 :param domain: The name of the domain containing the | |
1051 workflow execution. | |
1052 | |
1053 :type run_id: string | |
1054 :param run_id: A system generated unique identifier for the | |
1055 workflow execution. | |
1056 | |
1057 :type workflow_id: string | |
1058 :param workflow_id: The user defined identifier associated | |
1059 with the workflow execution. | |
1060 | |
1061 :type maximum_page_size: integer | |
1062 :param maximum_page_size: Specifies the maximum number of | |
1063 history events returned in one page. The next page in the | |
1064 result is identified by the NextPageToken returned. By default | |
1065 100 history events are returned in a page but the caller can | |
1066 override this value to a page size smaller than the | |
1067 default. You cannot specify a page size larger than 100. | |
1068 | |
1069 :type next_page_token: string | |
1070 :param next_page_token: If a NextPageToken is returned, the | |
1071 result has more than one pages. To get the next page, repeat | |
1072 the call and specify the nextPageToken with all other | |
1073 arguments unchanged. | |
1074 | |
1075 :type reverse_order: boolean | |
1076 :param reverse_order: When set to true, returns the events in | |
1077 reverse order. By default the results are returned in | |
1078 ascending order of the eventTimeStamp of the events. | |
1079 | |
1080 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1081 """ | |
1082 return self.json_request('GetWorkflowExecutionHistory', { | |
1083 'domain': domain, | |
1084 'execution': {'runId': run_id, | |
1085 'workflowId': workflow_id}, | |
1086 'maximumPageSize': maximum_page_size, | |
1087 'nextPageToken': next_page_token, | |
1088 'reverseOrder': reverse_order, | |
1089 }) | |
1090 | |
1091 def count_open_workflow_executions(self, domain, latest_date, oldest_date, | |
1092 tag=None, | |
1093 workflow_id=None, | |
1094 workflow_name=None, | |
1095 workflow_version=None): | |
1096 """ | |
1097 Returns the number of open workflow executions within the | |
1098 given domain that meet the specified filtering criteria. | |
1099 | |
1100 .. note: | |
1101 workflow_id, workflow_name/workflow_version and tag are mutually | |
1102 exclusive. You can specify at most one of these in a request. | |
1103 | |
1104 :type domain: string | |
1105 :param domain: The name of the domain containing the | |
1106 workflow executions to count. | |
1107 | |
1108 :type latest_date: timestamp | |
1109 :param latest_date: Specifies the latest start or close date | |
1110 and time to return. | |
1111 | |
1112 :type oldest_date: timestamp | |
1113 :param oldest_date: Specifies the oldest start or close date | |
1114 and time to return. | |
1115 | |
1116 :type workflow_name: string | |
1117 :param workflow_name: Name of the workflow type to filter on. | |
1118 | |
1119 :type workflow_version: string | |
1120 :param workflow_version: Version of the workflow type to filter on. | |
1121 | |
1122 :type tag: string | |
1123 :param tag: If specified, only executions that have a tag | |
1124 that matches the filter are counted. | |
1125 | |
1126 :type workflow_id: string | |
1127 :param workflow_id: If specified, only workflow executions | |
1128 matching the workflow_id are counted. | |
1129 | |
1130 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1131 """ | |
1132 return self.json_request('CountOpenWorkflowExecutions', { | |
1133 'domain': domain, | |
1134 'startTimeFilter': {'oldestDate': oldest_date, | |
1135 'latestDate': latest_date}, | |
1136 'typeFilter': {'name': workflow_name, | |
1137 'version': workflow_version}, | |
1138 'executionFilter': {'workflowId': workflow_id}, | |
1139 'tagFilter': {'tag': tag}, | |
1140 }) | |
1141 | |
1142 def list_open_workflow_executions(self, domain, | |
1143 oldest_date, | |
1144 latest_date=None, | |
1145 tag=None, | |
1146 workflow_id=None, | |
1147 workflow_name=None, | |
1148 workflow_version=None, | |
1149 maximum_page_size=None, | |
1150 next_page_token=None, | |
1151 reverse_order=None): | |
1152 """ | |
1153 Returns the list of open workflow executions within the | |
1154 given domain that meet the specified filtering criteria. | |
1155 | |
1156 .. note: | |
1157 workflow_id, workflow_name/workflow_version | |
1158 and tag are mutually exclusive. You can specify at most | |
1159 one of these in a request. | |
1160 | |
1161 :type domain: string | |
1162 :param domain: The name of the domain containing the | |
1163 workflow executions to count. | |
1164 | |
1165 :type latest_date: timestamp | |
1166 :param latest_date: Specifies the latest start or close date | |
1167 and time to return. | |
1168 | |
1169 :type oldest_date: timestamp | |
1170 :param oldest_date: Specifies the oldest start or close date | |
1171 and time to return. | |
1172 | |
1173 :type tag: string | |
1174 :param tag: If specified, only executions that have a tag | |
1175 that matches the filter are counted. | |
1176 | |
1177 :type workflow_id: string | |
1178 :param workflow_id: If specified, only workflow executions | |
1179 matching the workflow_id are counted. | |
1180 | |
1181 :type workflow_name: string | |
1182 :param workflow_name: Name of the workflow type to filter on. | |
1183 | |
1184 :type workflow_version: string | |
1185 :param workflow_version: Version of the workflow type to filter on. | |
1186 | |
1187 :type maximum_page_size: integer | |
1188 :param maximum_page_size: The maximum number of results | |
1189 returned in each page. The default is 100, but the caller can | |
1190 override this value to a page size smaller than the | |
1191 default. You cannot specify a page size greater than 100. | |
1192 | |
1193 :type next_page_token: string | |
1194 :param next_page_token: If on a previous call to this method a | |
1195 NextPageToken was returned, the results are being | |
1196 paginated. To get the next page of results, repeat the call | |
1197 with the returned token and all other arguments unchanged. | |
1198 | |
1199 :type reverse_order: boolean | |
1200 :param reverse_order: When set to true, returns the results in | |
1201 reverse order. By default the results are returned in | |
1202 descending order of the start or the close time of the | |
1203 executions. | |
1204 | |
1205 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1206 | |
1207 """ | |
1208 return self.json_request('ListOpenWorkflowExecutions', { | |
1209 'domain': domain, | |
1210 'startTimeFilter': {'oldestDate': oldest_date, | |
1211 'latestDate': latest_date}, | |
1212 'tagFilter': {'tag': tag}, | |
1213 'typeFilter': {'name': workflow_name, | |
1214 'version': workflow_version}, | |
1215 'executionFilter': {'workflowId': workflow_id}, | |
1216 'maximumPageSize': maximum_page_size, | |
1217 'nextPageToken': next_page_token, | |
1218 'reverseOrder': reverse_order, | |
1219 }) | |
1220 | |
1221 def count_closed_workflow_executions(self, domain, | |
1222 start_latest_date=None, | |
1223 start_oldest_date=None, | |
1224 close_latest_date=None, | |
1225 close_oldest_date=None, | |
1226 close_status=None, | |
1227 tag=None, | |
1228 workflow_id=None, | |
1229 workflow_name=None, | |
1230 workflow_version=None): | |
1231 """ | |
1232 Returns the number of closed workflow executions within the | |
1233 given domain that meet the specified filtering criteria. | |
1234 | |
1235 .. note: | |
1236 close_status, workflow_id, workflow_name/workflow_version | |
1237 and tag are mutually exclusive. You can specify at most | |
1238 one of these in a request. | |
1239 | |
1240 .. note: | |
1241 start_latest_date/start_oldest_date and | |
1242 close_latest_date/close_oldest_date are mutually | |
1243 exclusive. You can specify at most one of these in a request. | |
1244 | |
1245 :type domain: string | |
1246 :param domain: The name of the domain containing the | |
1247 workflow executions to count. | |
1248 | |
1249 :type start_latest_date: timestamp | |
1250 :param start_latest_date: If specified, only workflow executions | |
1251 that meet the start time criteria of the filter are counted. | |
1252 | |
1253 :type start_oldest_date: timestamp | |
1254 :param start_oldest_date: If specified, only workflow executions | |
1255 that meet the start time criteria of the filter are counted. | |
1256 | |
1257 :type close_latest_date: timestamp | |
1258 :param close_latest_date: If specified, only workflow executions | |
1259 that meet the close time criteria of the filter are counted. | |
1260 | |
1261 :type close_oldest_date: timestamp | |
1262 :param close_oldest_date: If specified, only workflow executions | |
1263 that meet the close time criteria of the filter are counted. | |
1264 | |
1265 :type close_status: string | |
1266 :param close_status: The close status that must match the close status | |
1267 of an execution for it to meet the criteria of this filter. | |
1268 Valid values are: | |
1269 | |
1270 * COMPLETED | |
1271 * FAILED | |
1272 * CANCELED | |
1273 * TERMINATED | |
1274 * CONTINUED_AS_NEW | |
1275 * TIMED_OUT | |
1276 | |
1277 :type tag: string | |
1278 :param tag: If specified, only executions that have a tag | |
1279 that matches the filter are counted. | |
1280 | |
1281 :type workflow_id: string | |
1282 :param workflow_id: If specified, only workflow executions | |
1283 matching the workflow_id are counted. | |
1284 | |
1285 :type workflow_name: string | |
1286 :param workflow_name: Name of the workflow type to filter on. | |
1287 | |
1288 :type workflow_version: string | |
1289 :param workflow_version: Version of the workflow type to filter on. | |
1290 | |
1291 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1292 """ | |
1293 return self.json_request('CountClosedWorkflowExecutions', { | |
1294 'domain': domain, | |
1295 'startTimeFilter': {'oldestDate': start_oldest_date, | |
1296 'latestDate': start_latest_date}, | |
1297 'closeTimeFilter': {'oldestDate': close_oldest_date, | |
1298 'latestDate': close_latest_date}, | |
1299 'closeStatusFilter': {'status': close_status}, | |
1300 'tagFilter': {'tag': tag}, | |
1301 'typeFilter': {'name': workflow_name, | |
1302 'version': workflow_version}, | |
1303 'executionFilter': {'workflowId': workflow_id} | |
1304 }) | |
1305 | |
1306 def list_closed_workflow_executions(self, domain, | |
1307 start_latest_date=None, | |
1308 start_oldest_date=None, | |
1309 close_latest_date=None, | |
1310 close_oldest_date=None, | |
1311 close_status=None, | |
1312 tag=None, | |
1313 workflow_id=None, | |
1314 workflow_name=None, | |
1315 workflow_version=None, | |
1316 maximum_page_size=None, | |
1317 next_page_token=None, | |
1318 reverse_order=None): | |
1319 """ | |
1320 Returns the number of closed workflow executions within the | |
1321 given domain that meet the specified filtering criteria. | |
1322 | |
1323 .. note: | |
1324 close_status, workflow_id, workflow_name/workflow_version | |
1325 and tag are mutually exclusive. You can specify at most | |
1326 one of these in a request. | |
1327 | |
1328 .. note: | |
1329 start_latest_date/start_oldest_date and | |
1330 close_latest_date/close_oldest_date are mutually | |
1331 exclusive. You can specify at most one of these in a request. | |
1332 | |
1333 :type domain: string | |
1334 :param domain: The name of the domain containing the | |
1335 workflow executions to count. | |
1336 | |
1337 :type start_latest_date: timestamp | |
1338 :param start_latest_date: If specified, only workflow executions | |
1339 that meet the start time criteria of the filter are counted. | |
1340 | |
1341 :type start_oldest_date: timestamp | |
1342 :param start_oldest_date: If specified, only workflow executions | |
1343 that meet the start time criteria of the filter are counted. | |
1344 | |
1345 :type close_latest_date: timestamp | |
1346 :param close_latest_date: If specified, only workflow executions | |
1347 that meet the close time criteria of the filter are counted. | |
1348 | |
1349 :type close_oldest_date: timestamp | |
1350 :param close_oldest_date: If specified, only workflow executions | |
1351 that meet the close time criteria of the filter are counted. | |
1352 | |
1353 :type close_status: string | |
1354 :param close_status: The close status that must match the close status | |
1355 of an execution for it to meet the criteria of this filter. | |
1356 Valid values are: | |
1357 | |
1358 * COMPLETED | |
1359 * FAILED | |
1360 * CANCELED | |
1361 * TERMINATED | |
1362 * CONTINUED_AS_NEW | |
1363 * TIMED_OUT | |
1364 | |
1365 :type tag: string | |
1366 :param tag: If specified, only executions that have a tag | |
1367 that matches the filter are counted. | |
1368 | |
1369 :type workflow_id: string | |
1370 :param workflow_id: If specified, only workflow executions | |
1371 matching the workflow_id are counted. | |
1372 | |
1373 :type workflow_name: string | |
1374 :param workflow_name: Name of the workflow type to filter on. | |
1375 | |
1376 :type workflow_version: string | |
1377 :param workflow_version: Version of the workflow type to filter on. | |
1378 | |
1379 :type maximum_page_size: integer | |
1380 :param maximum_page_size: The maximum number of results | |
1381 returned in each page. The default is 100, but the caller can | |
1382 override this value to a page size smaller than the | |
1383 default. You cannot specify a page size greater than 100. | |
1384 | |
1385 :type next_page_token: string | |
1386 :param next_page_token: If on a previous call to this method a | |
1387 NextPageToken was returned, the results are being | |
1388 paginated. To get the next page of results, repeat the call | |
1389 with the returned token and all other arguments unchanged. | |
1390 | |
1391 :type reverse_order: boolean | |
1392 :param reverse_order: When set to true, returns the results in | |
1393 reverse order. By default the results are returned in | |
1394 descending order of the start or the close time of the | |
1395 executions. | |
1396 | |
1397 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1398 """ | |
1399 return self.json_request('ListClosedWorkflowExecutions', { | |
1400 'domain': domain, | |
1401 'startTimeFilter': {'oldestDate': start_oldest_date, | |
1402 'latestDate': start_latest_date}, | |
1403 'closeTimeFilter': {'oldestDate': close_oldest_date, | |
1404 'latestDate': close_latest_date}, | |
1405 'executionFilter': {'workflowId': workflow_id}, | |
1406 'closeStatusFilter': {'status': close_status}, | |
1407 'tagFilter': {'tag': tag}, | |
1408 'typeFilter': {'name': workflow_name, | |
1409 'version': workflow_version}, | |
1410 'maximumPageSize': maximum_page_size, | |
1411 'nextPageToken': next_page_token, | |
1412 'reverseOrder': reverse_order, | |
1413 }) | |
1414 | |
1415 ## Domain Visibility | |
1416 | |
1417 def list_domains(self, registration_status, | |
1418 maximum_page_size=None, | |
1419 next_page_token=None, reverse_order=None): | |
1420 """ | |
1421 Returns the list of domains registered in the account. The | |
1422 results may be split into multiple pages. To retrieve | |
1423 subsequent pages, make the call again using the nextPageToken | |
1424 returned by the initial call. | |
1425 | |
1426 :type registration_status: string | |
1427 :param registration_status: Specifies the registration status | |
1428 of the domains to list. Valid Values: | |
1429 | |
1430 * REGISTERED | |
1431 * DEPRECATED | |
1432 | |
1433 :type maximum_page_size: integer | |
1434 :param maximum_page_size: The maximum number of results | |
1435 returned in each page. The default is 100, but the caller can | |
1436 override this value to a page size smaller than the | |
1437 default. You cannot specify a page size greater than 100. | |
1438 | |
1439 :type next_page_token: string | |
1440 :param next_page_token: If on a previous call to this method a | |
1441 NextPageToken was returned, the result has more than one | |
1442 page. To get the next page of results, repeat the call with | |
1443 the returned token and all other arguments unchanged. | |
1444 | |
1445 :type reverse_order: boolean | |
1446 :param reverse_order: When set to true, returns the results in | |
1447 reverse order. By default the results are returned in | |
1448 ascending alphabetical order of the name of the domains. | |
1449 | |
1450 :raises: SWFOperationNotPermittedError | |
1451 """ | |
1452 return self.json_request('ListDomains', { | |
1453 'registrationStatus': registration_status, | |
1454 'maximumPageSize': maximum_page_size, | |
1455 'nextPageToken': next_page_token, | |
1456 'reverseOrder': reverse_order, | |
1457 }) | |
1458 | |
1459 def describe_domain(self, name): | |
1460 """ | |
1461 Returns information about the specified domain including | |
1462 description and status. | |
1463 | |
1464 :type name: string | |
1465 :param name: The name of the domain to describe. | |
1466 | |
1467 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1468 """ | |
1469 return self.json_request('DescribeDomain', {'name': name}) | |
1470 | |
1471 ## Task List Visibility | |
1472 | |
1473 def count_pending_decision_tasks(self, domain, task_list): | |
1474 """ | |
1475 Returns the estimated number of decision tasks in the | |
1476 specified task list. The count returned is an approximation | |
1477 and is not guaranteed to be exact. If you specify a task list | |
1478 that no decision task was ever scheduled in then 0 will be | |
1479 returned. | |
1480 | |
1481 :type domain: string | |
1482 :param domain: The name of the domain that contains the task list. | |
1483 | |
1484 :type task_list: string | |
1485 :param task_list: The name of the task list. | |
1486 | |
1487 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1488 """ | |
1489 return self.json_request('CountPendingDecisionTasks', { | |
1490 'domain': domain, | |
1491 'taskList': {'name': task_list} | |
1492 }) | |
1493 | |
1494 def count_pending_activity_tasks(self, domain, task_list): | |
1495 """ | |
1496 Returns the estimated number of activity tasks in the | |
1497 specified task list. The count returned is an approximation | |
1498 and is not guaranteed to be exact. If you specify a task list | |
1499 that no activity task was ever scheduled in then 0 will be | |
1500 returned. | |
1501 | |
1502 :type domain: string | |
1503 :param domain: The name of the domain that contains the task list. | |
1504 | |
1505 :type task_list: string | |
1506 :param task_list: The name of the task list. | |
1507 | |
1508 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1509 """ | |
1510 return self.json_request('CountPendingActivityTasks', { | |
1511 'domain': domain, | |
1512 'taskList': {'name': task_list} | |
1513 }) |