Mercurial > repos > bcclaywell > argo_navis
comparison venv/lib/python2.7/site-packages/boto/swf/layer1.py @ 0:d67268158946 draft
planemo upload commit a3f181f5f126803c654b3a66dd4e83a48f7e203b
author | bcclaywell |
---|---|
date | Mon, 12 Oct 2015 17:43:33 -0400 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:d67268158946 |
---|---|
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 Returns information about the specified activity type. This | |
664 includes configuration settings provided at registration time | |
665 as well as other general information about the type. | |
666 | |
667 :type domain: string | |
668 :param domain: The name of the domain in which the activity | |
669 type is registered. | |
670 | |
671 :type activity_name: string | |
672 :param activity_name: The name of this activity. | |
673 | |
674 :type activity_version: string | |
675 :param activity_version: The version of this activity. | |
676 | |
677 :raises: UnknownResourceFault, TypeDeprecatedFault, | |
678 SWFOperationNotPermittedError | |
679 """ | |
680 return self.json_request('DeprecateActivityType', { | |
681 'domain': domain, | |
682 'activityType': {'name': activity_name, | |
683 'version': activity_version} | |
684 }) | |
685 | |
686 ## Workflow Management | |
687 | |
688 def register_workflow_type(self, domain, name, version, | |
689 task_list=None, | |
690 default_child_policy=None, | |
691 default_execution_start_to_close_timeout=None, | |
692 default_task_start_to_close_timeout=None, | |
693 description=None): | |
694 """ | |
695 Registers a new workflow type and its configuration settings | |
696 in the specified domain. | |
697 | |
698 :type domain: string | |
699 :param domain: The name of the domain in which to register | |
700 the workflow type. | |
701 | |
702 :type name: string | |
703 :param name: The name of the workflow type. | |
704 | |
705 :type version: string | |
706 :param version: The version of the workflow type. | |
707 | |
708 :type task_list: list of name, version of tasks | |
709 :param task_list: If set, specifies the default task list to use | |
710 for scheduling decision tasks for executions of this workflow | |
711 type. This default is used only if a task list is not provided | |
712 when starting the execution through the StartWorkflowExecution | |
713 Action or StartChildWorkflowExecution Decision. | |
714 | |
715 :type default_child_policy: string | |
716 | |
717 :param default_child_policy: If set, specifies the default | |
718 policy to use for the child workflow executions when a | |
719 workflow execution of this type is terminated, by calling the | |
720 TerminateWorkflowExecution action explicitly or due to an | |
721 expired timeout. This default can be overridden when starting | |
722 a workflow execution using the StartWorkflowExecution action | |
723 or the StartChildWorkflowExecution Decision. The supported | |
724 child policies are: | |
725 | |
726 * TERMINATE: the child executions will be terminated. | |
727 | |
728 * REQUEST_CANCEL: a request to cancel will be attempted | |
729 for each child execution by recording a | |
730 WorkflowExecutionCancelRequested event in its | |
731 history. It is up to the decider to take appropriate | |
732 actions when it receives an execution history with this | |
733 event. | |
734 | |
735 * ABANDON: no action will be taken. The child executions | |
736 will continue to run.no docs | |
737 | |
738 :type default_execution_start_to_close_timeout: string | |
739 :param default_execution_start_to_close_timeout: If set, | |
740 specifies the default maximum duration for executions of this | |
741 workflow type. You can override this default when starting an | |
742 execution through the StartWorkflowExecution Action or | |
743 StartChildWorkflowExecution Decision. | |
744 | |
745 :type default_task_start_to_close_timeout: string | |
746 :param default_task_start_to_close_timeout: If set, specifies | |
747 the default maximum duration of decision tasks for this | |
748 workflow type. This default can be overridden when starting a | |
749 workflow execution using the StartWorkflowExecution action or | |
750 the StartChildWorkflowExecution Decision. | |
751 | |
752 :type description: string | |
753 :param description: Textual description of the workflow type. | |
754 | |
755 :raises: SWFTypeAlreadyExistsError, SWFLimitExceededError, | |
756 UnknownResourceFault, SWFOperationNotPermittedError | |
757 """ | |
758 return self.json_request('RegisterWorkflowType', { | |
759 'domain': domain, | |
760 'name': name, | |
761 'version': version, | |
762 'defaultTaskList': {'name': task_list}, | |
763 'defaultChildPolicy': default_child_policy, | |
764 'defaultExecutionStartToCloseTimeout': default_execution_start_to_close_timeout, | |
765 'defaultTaskStartToCloseTimeout': default_task_start_to_close_timeout, | |
766 'description': description, | |
767 }) | |
768 | |
769 def deprecate_workflow_type(self, domain, workflow_name, workflow_version): | |
770 """ | |
771 Deprecates the specified workflow type. After a workflow type | |
772 has been deprecated, you cannot create new executions of that | |
773 type. Executions that were started before the type was | |
774 deprecated will continue to run. A deprecated workflow type | |
775 may still be used when calling visibility actions. | |
776 | |
777 :type domain: string | |
778 :param domain: The name of the domain in which the workflow | |
779 type is registered. | |
780 | |
781 :type workflow_name: string | |
782 :param workflow_name: The name of the workflow type. | |
783 | |
784 :type workflow_version: string | |
785 :param workflow_version: The version of the workflow type. | |
786 | |
787 :raises: UnknownResourceFault, TypeDeprecatedFault, | |
788 SWFOperationNotPermittedError | |
789 """ | |
790 return self.json_request('DeprecateWorkflowType', { | |
791 'domain': domain, | |
792 'workflowType': {'name': workflow_name, | |
793 'version': workflow_version}, | |
794 }) | |
795 | |
796 ## Domain Management | |
797 | |
798 def register_domain(self, name, | |
799 workflow_execution_retention_period_in_days, | |
800 description=None): | |
801 """ | |
802 Registers a new domain. | |
803 | |
804 :type name: string | |
805 :param name: Name of the domain to register. The name must be unique. | |
806 | |
807 :type workflow_execution_retention_period_in_days: string | |
808 | |
809 :param workflow_execution_retention_period_in_days: Specifies | |
810 the duration *in days* for which the record (including the | |
811 history) of workflow executions in this domain should be kept | |
812 by the service. After the retention period, the workflow | |
813 execution will not be available in the results of visibility | |
814 calls. If a duration of NONE is specified, the records for | |
815 workflow executions in this domain are not retained at all. | |
816 | |
817 :type description: string | |
818 :param description: Textual description of the domain. | |
819 | |
820 :raises: SWFDomainAlreadyExistsError, SWFLimitExceededError, | |
821 SWFOperationNotPermittedError | |
822 """ | |
823 return self.json_request('RegisterDomain', { | |
824 'name': name, | |
825 'workflowExecutionRetentionPeriodInDays': workflow_execution_retention_period_in_days, | |
826 'description': description, | |
827 }) | |
828 | |
829 def deprecate_domain(self, name): | |
830 """ | |
831 Deprecates the specified domain. After a domain has been | |
832 deprecated it cannot be used to create new workflow executions | |
833 or register new types. However, you can still use visibility | |
834 actions on this domain. Deprecating a domain also deprecates | |
835 all activity and workflow types registered in the | |
836 domain. Executions that were started before the domain was | |
837 deprecated will continue to run. | |
838 | |
839 :type name: string | |
840 :param name: The name of the domain to deprecate. | |
841 | |
842 :raises: UnknownResourceFault, DomainDeprecatedFault, | |
843 SWFOperationNotPermittedError | |
844 """ | |
845 return self.json_request('DeprecateDomain', {'name': name}) | |
846 | |
847 # Visibility Actions | |
848 | |
849 ## Activity Visibility | |
850 | |
851 def list_activity_types(self, domain, registration_status, | |
852 name=None, | |
853 maximum_page_size=None, | |
854 next_page_token=None, reverse_order=None): | |
855 """ | |
856 Returns information about all activities registered in the | |
857 specified domain that match the specified name and | |
858 registration status. The result includes information like | |
859 creation date, current status of the activity, etc. The | |
860 results may be split into multiple pages. To retrieve | |
861 subsequent pages, make the call again using the nextPageToken | |
862 returned by the initial call. | |
863 | |
864 :type domain: string | |
865 :param domain: The name of the domain in which the activity | |
866 types have been registered. | |
867 | |
868 :type registration_status: string | |
869 :param registration_status: Specifies the registration status | |
870 of the activity types to list. Valid values are: | |
871 | |
872 * REGISTERED | |
873 * DEPRECATED | |
874 | |
875 :type name: string | |
876 :param name: If specified, only lists the activity types that | |
877 have this name. | |
878 | |
879 :type maximum_page_size: integer | |
880 :param maximum_page_size: The maximum number of results | |
881 returned in each page. The default is 100, but the caller can | |
882 override this value to a page size smaller than the | |
883 default. You cannot specify a page size greater than 100. | |
884 | |
885 :type next_page_token: string | |
886 :param next_page_token: If on a previous call to this method a | |
887 NextResultToken was returned, the results have more than one | |
888 page. To get the next page of results, repeat the call with | |
889 the nextPageToken and keep all other arguments unchanged. | |
890 | |
891 :type reverse_order: boolean | |
892 | |
893 :param reverse_order: When set to true, returns the results in | |
894 reverse order. By default the results are returned in | |
895 ascending alphabetical order of the name of the activity | |
896 types. | |
897 | |
898 :raises: SWFOperationNotPermittedError, UnknownResourceFault | |
899 """ | |
900 return self.json_request('ListActivityTypes', { | |
901 'domain': domain, | |
902 'name': name, | |
903 'registrationStatus': registration_status, | |
904 'maximumPageSize': maximum_page_size, | |
905 'nextPageToken': next_page_token, | |
906 'reverseOrder': reverse_order, | |
907 }) | |
908 | |
909 def describe_activity_type(self, domain, activity_name, activity_version): | |
910 """ | |
911 Returns information about the specified activity type. This | |
912 includes configuration settings provided at registration time | |
913 as well as other general information about the type. | |
914 | |
915 :type domain: string | |
916 :param domain: The name of the domain in which the activity | |
917 type is registered. | |
918 | |
919 :type activity_name: string | |
920 :param activity_name: The name of this activity. | |
921 | |
922 :type activity_version: string | |
923 :param activity_version: The version of this activity. | |
924 | |
925 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
926 """ | |
927 return self.json_request('DescribeActivityType', { | |
928 'domain': domain, | |
929 'activityType': {'name': activity_name, | |
930 'version': activity_version} | |
931 }) | |
932 | |
933 ## Workflow Visibility | |
934 | |
935 def list_workflow_types(self, domain, registration_status, | |
936 maximum_page_size=None, name=None, | |
937 next_page_token=None, reverse_order=None): | |
938 """ | |
939 Returns information about workflow types in the specified | |
940 domain. The results may be split into multiple pages that can | |
941 be retrieved by making the call repeatedly. | |
942 | |
943 :type domain: string | |
944 :param domain: The name of the domain in which the workflow | |
945 types have been registered. | |
946 | |
947 :type registration_status: string | |
948 :param registration_status: Specifies the registration status | |
949 of the activity types to list. Valid values are: | |
950 | |
951 * REGISTERED | |
952 * DEPRECATED | |
953 | |
954 :type name: string | |
955 :param name: If specified, lists the workflow type with this name. | |
956 | |
957 :type maximum_page_size: integer | |
958 :param maximum_page_size: The maximum number of results | |
959 returned in each page. The default is 100, but the caller can | |
960 override this value to a page size smaller than the | |
961 default. You cannot specify a page size greater than 100. | |
962 | |
963 :type next_page_token: string | |
964 :param next_page_token: If on a previous call to this method a | |
965 NextPageToken was returned, the results are being | |
966 paginated. To get the next page of results, repeat the call | |
967 with the returned token and all other arguments unchanged. | |
968 | |
969 :type reverse_order: boolean | |
970 :param reverse_order: When set to true, returns the results in | |
971 reverse order. By default the results are returned in | |
972 ascending alphabetical order of the name of the workflow | |
973 types. | |
974 | |
975 :raises: SWFOperationNotPermittedError, UnknownResourceFault | |
976 """ | |
977 return self.json_request('ListWorkflowTypes', { | |
978 'domain': domain, | |
979 'name': name, | |
980 'registrationStatus': registration_status, | |
981 'maximumPageSize': maximum_page_size, | |
982 'nextPageToken': next_page_token, | |
983 'reverseOrder': reverse_order, | |
984 }) | |
985 | |
986 def describe_workflow_type(self, domain, workflow_name, workflow_version): | |
987 """ | |
988 Returns information about the specified workflow type. This | |
989 includes configuration settings specified when the type was | |
990 registered and other information such as creation date, | |
991 current status, etc. | |
992 | |
993 :type domain: string | |
994 :param domain: The name of the domain in which this workflow | |
995 type is registered. | |
996 | |
997 :type workflow_name: string | |
998 :param workflow_name: The name of the workflow type. | |
999 | |
1000 :type workflow_version: string | |
1001 :param workflow_version: The version of the workflow type. | |
1002 | |
1003 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1004 """ | |
1005 return self.json_request('DescribeWorkflowType', { | |
1006 'domain': domain, | |
1007 'workflowType': {'name': workflow_name, | |
1008 'version': workflow_version} | |
1009 }) | |
1010 | |
1011 ## Workflow Execution Visibility | |
1012 | |
1013 def describe_workflow_execution(self, domain, run_id, workflow_id): | |
1014 """ | |
1015 Returns information about the specified workflow execution | |
1016 including its type and some statistics. | |
1017 | |
1018 :type domain: string | |
1019 :param domain: The name of the domain containing the | |
1020 workflow execution. | |
1021 | |
1022 :type run_id: string | |
1023 :param run_id: A system generated unique identifier for the | |
1024 workflow execution. | |
1025 | |
1026 :type workflow_id: string | |
1027 :param workflow_id: The user defined identifier associated | |
1028 with the workflow execution. | |
1029 | |
1030 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1031 """ | |
1032 return self.json_request('DescribeWorkflowExecution', { | |
1033 'domain': domain, | |
1034 'execution': {'runId': run_id, | |
1035 'workflowId': workflow_id}, | |
1036 }) | |
1037 | |
1038 def get_workflow_execution_history(self, domain, run_id, workflow_id, | |
1039 maximum_page_size=None, | |
1040 next_page_token=None, | |
1041 reverse_order=None): | |
1042 """ | |
1043 Returns the history of the specified workflow execution. The | |
1044 results may be split into multiple pages. To retrieve | |
1045 subsequent pages, make the call again using the nextPageToken | |
1046 returned by the initial call. | |
1047 | |
1048 :type domain: string | |
1049 :param domain: The name of the domain containing the | |
1050 workflow execution. | |
1051 | |
1052 :type run_id: string | |
1053 :param run_id: A system generated unique identifier for the | |
1054 workflow execution. | |
1055 | |
1056 :type workflow_id: string | |
1057 :param workflow_id: The user defined identifier associated | |
1058 with the workflow execution. | |
1059 | |
1060 :type maximum_page_size: integer | |
1061 :param maximum_page_size: Specifies the maximum number of | |
1062 history events returned in one page. The next page in the | |
1063 result is identified by the NextPageToken returned. By default | |
1064 100 history events are returned in a page but the caller can | |
1065 override this value to a page size smaller than the | |
1066 default. You cannot specify a page size larger than 100. | |
1067 | |
1068 :type next_page_token: string | |
1069 :param next_page_token: If a NextPageToken is returned, the | |
1070 result has more than one pages. To get the next page, repeat | |
1071 the call and specify the nextPageToken with all other | |
1072 arguments unchanged. | |
1073 | |
1074 :type reverse_order: boolean | |
1075 :param reverse_order: When set to true, returns the events in | |
1076 reverse order. By default the results are returned in | |
1077 ascending order of the eventTimeStamp of the events. | |
1078 | |
1079 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1080 """ | |
1081 return self.json_request('GetWorkflowExecutionHistory', { | |
1082 'domain': domain, | |
1083 'execution': {'runId': run_id, | |
1084 'workflowId': workflow_id}, | |
1085 'maximumPageSize': maximum_page_size, | |
1086 'nextPageToken': next_page_token, | |
1087 'reverseOrder': reverse_order, | |
1088 }) | |
1089 | |
1090 def count_open_workflow_executions(self, domain, latest_date, oldest_date, | |
1091 tag=None, | |
1092 workflow_id=None, | |
1093 workflow_name=None, | |
1094 workflow_version=None): | |
1095 """ | |
1096 Returns the number of open workflow executions within the | |
1097 given domain that meet the specified filtering criteria. | |
1098 | |
1099 .. note: | |
1100 workflow_id, workflow_name/workflow_version and tag are mutually | |
1101 exclusive. You can specify at most one of these in a request. | |
1102 | |
1103 :type domain: string | |
1104 :param domain: The name of the domain containing the | |
1105 workflow executions to count. | |
1106 | |
1107 :type latest_date: timestamp | |
1108 :param latest_date: Specifies the latest start or close date | |
1109 and time to return. | |
1110 | |
1111 :type oldest_date: timestamp | |
1112 :param oldest_date: Specifies the oldest start or close date | |
1113 and time to return. | |
1114 | |
1115 :type workflow_name: string | |
1116 :param workflow_name: Name of the workflow type to filter on. | |
1117 | |
1118 :type workflow_version: string | |
1119 :param workflow_version: Version of the workflow type to filter on. | |
1120 | |
1121 :type tag: string | |
1122 :param tag: If specified, only executions that have a tag | |
1123 that matches the filter are counted. | |
1124 | |
1125 :type workflow_id: string | |
1126 :param workflow_id: If specified, only workflow executions | |
1127 matching the workflow_id are counted. | |
1128 | |
1129 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1130 """ | |
1131 return self.json_request('CountOpenWorkflowExecutions', { | |
1132 'domain': domain, | |
1133 'startTimeFilter': {'oldestDate': oldest_date, | |
1134 'latestDate': latest_date}, | |
1135 'typeFilter': {'name': workflow_name, | |
1136 'version': workflow_version}, | |
1137 'executionFilter': {'workflowId': workflow_id}, | |
1138 'tagFilter': {'tag': tag}, | |
1139 }) | |
1140 | |
1141 def list_open_workflow_executions(self, domain, | |
1142 oldest_date, | |
1143 latest_date=None, | |
1144 tag=None, | |
1145 workflow_id=None, | |
1146 workflow_name=None, | |
1147 workflow_version=None, | |
1148 maximum_page_size=None, | |
1149 next_page_token=None, | |
1150 reverse_order=None): | |
1151 """ | |
1152 Returns the list of open workflow executions within the | |
1153 given domain that meet the specified filtering criteria. | |
1154 | |
1155 .. note: | |
1156 workflow_id, workflow_name/workflow_version | |
1157 and tag are mutually exclusive. You can specify at most | |
1158 one of these in a request. | |
1159 | |
1160 :type domain: string | |
1161 :param domain: The name of the domain containing the | |
1162 workflow executions to count. | |
1163 | |
1164 :type latest_date: timestamp | |
1165 :param latest_date: Specifies the latest start or close date | |
1166 and time to return. | |
1167 | |
1168 :type oldest_date: timestamp | |
1169 :param oldest_date: Specifies the oldest start or close date | |
1170 and time to return. | |
1171 | |
1172 :type tag: string | |
1173 :param tag: If specified, only executions that have a tag | |
1174 that matches the filter are counted. | |
1175 | |
1176 :type workflow_id: string | |
1177 :param workflow_id: If specified, only workflow executions | |
1178 matching the workflow_id are counted. | |
1179 | |
1180 :type workflow_name: string | |
1181 :param workflow_name: Name of the workflow type to filter on. | |
1182 | |
1183 :type workflow_version: string | |
1184 :param workflow_version: Version of the workflow type to filter on. | |
1185 | |
1186 :type maximum_page_size: integer | |
1187 :param maximum_page_size: The maximum number of results | |
1188 returned in each page. The default is 100, but the caller can | |
1189 override this value to a page size smaller than the | |
1190 default. You cannot specify a page size greater than 100. | |
1191 | |
1192 :type next_page_token: string | |
1193 :param next_page_token: If on a previous call to this method a | |
1194 NextPageToken was returned, the results are being | |
1195 paginated. To get the next page of results, repeat the call | |
1196 with the returned token and all other arguments unchanged. | |
1197 | |
1198 :type reverse_order: boolean | |
1199 :param reverse_order: When set to true, returns the results in | |
1200 reverse order. By default the results are returned in | |
1201 descending order of the start or the close time of the | |
1202 executions. | |
1203 | |
1204 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1205 | |
1206 """ | |
1207 return self.json_request('ListOpenWorkflowExecutions', { | |
1208 'domain': domain, | |
1209 'startTimeFilter': {'oldestDate': oldest_date, | |
1210 'latestDate': latest_date}, | |
1211 'tagFilter': {'tag': tag}, | |
1212 'typeFilter': {'name': workflow_name, | |
1213 'version': workflow_version}, | |
1214 'executionFilter': {'workflowId': workflow_id}, | |
1215 'maximumPageSize': maximum_page_size, | |
1216 'nextPageToken': next_page_token, | |
1217 'reverseOrder': reverse_order, | |
1218 }) | |
1219 | |
1220 def count_closed_workflow_executions(self, domain, | |
1221 start_latest_date=None, | |
1222 start_oldest_date=None, | |
1223 close_latest_date=None, | |
1224 close_oldest_date=None, | |
1225 close_status=None, | |
1226 tag=None, | |
1227 workflow_id=None, | |
1228 workflow_name=None, | |
1229 workflow_version=None): | |
1230 """ | |
1231 Returns the number of closed workflow executions within the | |
1232 given domain that meet the specified filtering criteria. | |
1233 | |
1234 .. note: | |
1235 close_status, workflow_id, workflow_name/workflow_version | |
1236 and tag are mutually exclusive. You can specify at most | |
1237 one of these in a request. | |
1238 | |
1239 .. note: | |
1240 start_latest_date/start_oldest_date and | |
1241 close_latest_date/close_oldest_date are mutually | |
1242 exclusive. You can specify at most one of these in a request. | |
1243 | |
1244 :type domain: string | |
1245 :param domain: The name of the domain containing the | |
1246 workflow executions to count. | |
1247 | |
1248 :type start_latest_date: timestamp | |
1249 :param start_latest_date: If specified, only workflow executions | |
1250 that meet the start time criteria of the filter are counted. | |
1251 | |
1252 :type start_oldest_date: timestamp | |
1253 :param start_oldest_date: If specified, only workflow executions | |
1254 that meet the start time criteria of the filter are counted. | |
1255 | |
1256 :type close_latest_date: timestamp | |
1257 :param close_latest_date: If specified, only workflow executions | |
1258 that meet the close time criteria of the filter are counted. | |
1259 | |
1260 :type close_oldest_date: timestamp | |
1261 :param close_oldest_date: If specified, only workflow executions | |
1262 that meet the close time criteria of the filter are counted. | |
1263 | |
1264 :type close_status: string | |
1265 :param close_status: The close status that must match the close status | |
1266 of an execution for it to meet the criteria of this filter. | |
1267 Valid values are: | |
1268 | |
1269 * COMPLETED | |
1270 * FAILED | |
1271 * CANCELED | |
1272 * TERMINATED | |
1273 * CONTINUED_AS_NEW | |
1274 * TIMED_OUT | |
1275 | |
1276 :type tag: string | |
1277 :param tag: If specified, only executions that have a tag | |
1278 that matches the filter are counted. | |
1279 | |
1280 :type workflow_id: string | |
1281 :param workflow_id: If specified, only workflow executions | |
1282 matching the workflow_id are counted. | |
1283 | |
1284 :type workflow_name: string | |
1285 :param workflow_name: Name of the workflow type to filter on. | |
1286 | |
1287 :type workflow_version: string | |
1288 :param workflow_version: Version of the workflow type to filter on. | |
1289 | |
1290 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1291 """ | |
1292 return self.json_request('CountClosedWorkflowExecutions', { | |
1293 'domain': domain, | |
1294 'startTimeFilter': {'oldestDate': start_oldest_date, | |
1295 'latestDate': start_latest_date}, | |
1296 'closeTimeFilter': {'oldestDate': close_oldest_date, | |
1297 'latestDate': close_latest_date}, | |
1298 'closeStatusFilter': {'status': close_status}, | |
1299 'tagFilter': {'tag': tag}, | |
1300 'typeFilter': {'name': workflow_name, | |
1301 'version': workflow_version}, | |
1302 'executionFilter': {'workflowId': workflow_id} | |
1303 }) | |
1304 | |
1305 def list_closed_workflow_executions(self, domain, | |
1306 start_latest_date=None, | |
1307 start_oldest_date=None, | |
1308 close_latest_date=None, | |
1309 close_oldest_date=None, | |
1310 close_status=None, | |
1311 tag=None, | |
1312 workflow_id=None, | |
1313 workflow_name=None, | |
1314 workflow_version=None, | |
1315 maximum_page_size=None, | |
1316 next_page_token=None, | |
1317 reverse_order=None): | |
1318 """ | |
1319 Returns the number of closed workflow executions within the | |
1320 given domain that meet the specified filtering criteria. | |
1321 | |
1322 .. note: | |
1323 close_status, workflow_id, workflow_name/workflow_version | |
1324 and tag are mutually exclusive. You can specify at most | |
1325 one of these in a request. | |
1326 | |
1327 .. note: | |
1328 start_latest_date/start_oldest_date and | |
1329 close_latest_date/close_oldest_date are mutually | |
1330 exclusive. You can specify at most one of these in a request. | |
1331 | |
1332 :type domain: string | |
1333 :param domain: The name of the domain containing the | |
1334 workflow executions to count. | |
1335 | |
1336 :type start_latest_date: timestamp | |
1337 :param start_latest_date: If specified, only workflow executions | |
1338 that meet the start time criteria of the filter are counted. | |
1339 | |
1340 :type start_oldest_date: timestamp | |
1341 :param start_oldest_date: If specified, only workflow executions | |
1342 that meet the start time criteria of the filter are counted. | |
1343 | |
1344 :type close_latest_date: timestamp | |
1345 :param close_latest_date: If specified, only workflow executions | |
1346 that meet the close time criteria of the filter are counted. | |
1347 | |
1348 :type close_oldest_date: timestamp | |
1349 :param close_oldest_date: If specified, only workflow executions | |
1350 that meet the close time criteria of the filter are counted. | |
1351 | |
1352 :type close_status: string | |
1353 :param close_status: The close status that must match the close status | |
1354 of an execution for it to meet the criteria of this filter. | |
1355 Valid values are: | |
1356 | |
1357 * COMPLETED | |
1358 * FAILED | |
1359 * CANCELED | |
1360 * TERMINATED | |
1361 * CONTINUED_AS_NEW | |
1362 * TIMED_OUT | |
1363 | |
1364 :type tag: string | |
1365 :param tag: If specified, only executions that have a tag | |
1366 that matches the filter are counted. | |
1367 | |
1368 :type workflow_id: string | |
1369 :param workflow_id: If specified, only workflow executions | |
1370 matching the workflow_id are counted. | |
1371 | |
1372 :type workflow_name: string | |
1373 :param workflow_name: Name of the workflow type to filter on. | |
1374 | |
1375 :type workflow_version: string | |
1376 :param workflow_version: Version of the workflow type to filter on. | |
1377 | |
1378 :type maximum_page_size: integer | |
1379 :param maximum_page_size: The maximum number of results | |
1380 returned in each page. The default is 100, but the caller can | |
1381 override this value to a page size smaller than the | |
1382 default. You cannot specify a page size greater than 100. | |
1383 | |
1384 :type next_page_token: string | |
1385 :param next_page_token: If on a previous call to this method a | |
1386 NextPageToken was returned, the results are being | |
1387 paginated. To get the next page of results, repeat the call | |
1388 with the returned token and all other arguments unchanged. | |
1389 | |
1390 :type reverse_order: boolean | |
1391 :param reverse_order: When set to true, returns the results in | |
1392 reverse order. By default the results are returned in | |
1393 descending order of the start or the close time of the | |
1394 executions. | |
1395 | |
1396 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1397 """ | |
1398 return self.json_request('ListClosedWorkflowExecutions', { | |
1399 'domain': domain, | |
1400 'startTimeFilter': {'oldestDate': start_oldest_date, | |
1401 'latestDate': start_latest_date}, | |
1402 'closeTimeFilter': {'oldestDate': close_oldest_date, | |
1403 'latestDate': close_latest_date}, | |
1404 'executionFilter': {'workflowId': workflow_id}, | |
1405 'closeStatusFilter': {'status': close_status}, | |
1406 'tagFilter': {'tag': tag}, | |
1407 'typeFilter': {'name': workflow_name, | |
1408 'version': workflow_version}, | |
1409 'maximumPageSize': maximum_page_size, | |
1410 'nextPageToken': next_page_token, | |
1411 'reverseOrder': reverse_order, | |
1412 }) | |
1413 | |
1414 ## Domain Visibility | |
1415 | |
1416 def list_domains(self, registration_status, | |
1417 maximum_page_size=None, | |
1418 next_page_token=None, reverse_order=None): | |
1419 """ | |
1420 Returns the list of domains registered in the account. The | |
1421 results may be split into multiple pages. To retrieve | |
1422 subsequent pages, make the call again using the nextPageToken | |
1423 returned by the initial call. | |
1424 | |
1425 :type registration_status: string | |
1426 :param registration_status: Specifies the registration status | |
1427 of the domains to list. Valid Values: | |
1428 | |
1429 * REGISTERED | |
1430 * DEPRECATED | |
1431 | |
1432 :type maximum_page_size: integer | |
1433 :param maximum_page_size: The maximum number of results | |
1434 returned in each page. The default is 100, but the caller can | |
1435 override this value to a page size smaller than the | |
1436 default. You cannot specify a page size greater than 100. | |
1437 | |
1438 :type next_page_token: string | |
1439 :param next_page_token: If on a previous call to this method a | |
1440 NextPageToken was returned, the result has more than one | |
1441 page. To get the next page of results, repeat the call with | |
1442 the returned token and all other arguments unchanged. | |
1443 | |
1444 :type reverse_order: boolean | |
1445 :param reverse_order: When set to true, returns the results in | |
1446 reverse order. By default the results are returned in | |
1447 ascending alphabetical order of the name of the domains. | |
1448 | |
1449 :raises: SWFOperationNotPermittedError | |
1450 """ | |
1451 return self.json_request('ListDomains', { | |
1452 'registrationStatus': registration_status, | |
1453 'maximumPageSize': maximum_page_size, | |
1454 'nextPageToken': next_page_token, | |
1455 'reverseOrder': reverse_order, | |
1456 }) | |
1457 | |
1458 def describe_domain(self, name): | |
1459 """ | |
1460 Returns information about the specified domain including | |
1461 description and status. | |
1462 | |
1463 :type name: string | |
1464 :param name: The name of the domain to describe. | |
1465 | |
1466 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1467 """ | |
1468 return self.json_request('DescribeDomain', {'name': name}) | |
1469 | |
1470 ## Task List Visibility | |
1471 | |
1472 def count_pending_decision_tasks(self, domain, task_list): | |
1473 """ | |
1474 Returns the estimated number of decision tasks in the | |
1475 specified task list. The count returned is an approximation | |
1476 and is not guaranteed to be exact. If you specify a task list | |
1477 that no decision task was ever scheduled in then 0 will be | |
1478 returned. | |
1479 | |
1480 :type domain: string | |
1481 :param domain: The name of the domain that contains the task list. | |
1482 | |
1483 :type task_list: string | |
1484 :param task_list: The name of the task list. | |
1485 | |
1486 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1487 """ | |
1488 return self.json_request('CountPendingDecisionTasks', { | |
1489 'domain': domain, | |
1490 'taskList': {'name': task_list} | |
1491 }) | |
1492 | |
1493 def count_pending_activity_tasks(self, domain, task_list): | |
1494 """ | |
1495 Returns the estimated number of activity tasks in the | |
1496 specified task list. The count returned is an approximation | |
1497 and is not guaranteed to be exact. If you specify a task list | |
1498 that no activity task was ever scheduled in then 0 will be | |
1499 returned. | |
1500 | |
1501 :type domain: string | |
1502 :param domain: The name of the domain that contains the task list. | |
1503 | |
1504 :type task_list: string | |
1505 :param task_list: The name of the task list. | |
1506 | |
1507 :raises: UnknownResourceFault, SWFOperationNotPermittedError | |
1508 """ | |
1509 return self.json_request('CountPendingActivityTasks', { | |
1510 'domain': domain, | |
1511 'taskList': {'name': task_list} | |
1512 }) |