• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
25import time
26
27import boto
28from boto.connection import AWSAuthConnection
29from boto.provider import Provider
30from boto.exception import SWFResponseError
31from boto.swf import exceptions as swf_exceptions
32from 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')
39Debug = 0
40
41
42class 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        })
1513