def really_start(*args, **kwargs): """Use this function to start a workflow by passing in the args.""" swf = swf_client if swf_client is not None else SWFClient() l_wid = wid # closure hack if l_wid is None: l_wid = uuid.uuid4() if serialize_input is None: input_data = Proxy.serialize_input(*args, **kwargs) else: input_data = serialize_input(*args, **kwargs) if len(input_data) > INPUT_SIZE: logger.error( "Input too large: %s/%s" % (len(input_data), INPUT_SIZE)) raise ValueError('Input too large.') try: r = swf.start_workflow_execution( domain, l_wid, name, version, input=input_data, priority=priority, task_list=task_list, execution_start_to_close_timeout=task_duration, task_start_to_close_timeout=workflow_duration, child_policy=child_policy, tags=tags, lambda_role=lambda_role) except ClientError as e: logger.exception('Error while starting the workflow:') raise e return r['runId']
def __call__(self, key, input_data, decision, *extra_args): """Execute the wrapped func registered with key passing the input_data. Any exra_args are also passed along to the wrapped_key. The actual actions are dispatched to the decision object and can be one of: * flush() - nothing to do, any pending actions should be commited * fail(e) - ignore pending actions, fail the execution * finish(e) - ignore pending actions, complete the execution * restart(serialized_input) - ignore pending actions, restart the execution """ try: wrapped_func = self.registry[key] except KeyError: logger.error("Colud not find implementation for key: %r", (key,)) return # Let it timeout try: serialized_result = wrapped_func(input_data, *extra_args) except SuspendTask: decision.flush() except TaskError as e: logger.exception('Unhandled task error in task:') decision.fail(e) except Restart as e: decision.restart(e.input_data) except Exception as e: logger.exception('Unhandled exception in task:') decision.fail(e) else: decision.finish(serialized_result)
def __call__(self, key, input_data, decision, *extra_args): """Execute the wrapped func registered with key passing the input_data. Any exra_args are also passed along to the wrapped_key. The actual actions are dispatched to the decision object and can be one of: * flush() - nothing to do, any pending actions should be commited * fail(e) - ignore pending actions, fail the execution * finish(e) - ignore pending actions, complete the execution * restart(serialized_input) - ignore pending actions, restart the execution """ try: wrapped_func = self.registry[key] except KeyError: logger.error("Colud not find implementation for key: %r", (key, )) return # Let it timeout try: serialized_result = wrapped_func(input_data, *extra_args) except SuspendTask: # only from workflows decision.flush() except TaskError as e: # only from workflows logger.exception('Unhandled task error in task:') decision.fail(e) except Restart as e: # only from workflows decision.restart(e.input_data) except Exception as e: logger.exception('Unhandled exception in task:') decision.fail(e) else: decision.finish(serialized_result)
def really_start(*args, **kwargs): """Use this function to start a workflow by passing in the args.""" l1 = layer1 if layer1 is not None else Layer1() l_wid = wid # closue hack if l_wid is None: l_wid = uuid.uuid4() if serialize_input is None: input_data = Proxy.serialize_input(*args, **kwargs) else: input_data = serialize_input(*args, **kwargs) if len(input_data) > INPUT_SIZE: logger.error("Input too large: %s/%s" % (len(input_data), INPUT_SIZE)) raise ValueError('Input too large.') try: r = l1.start_workflow_execution( str(domain), str(l_wid), str(name), str(version), task_list=str_or_none(task_list), execution_start_to_close_timeout=str_or_none(workflow_duration), task_start_to_close_timeout=str_or_none(decision_duration), input=str(input_data), child_policy=cp_encode(child_policy), tag_list=tags_encode(tags)) except SWFResponseError: logger.exception('Error while starting the workflow:') raise RuntimeError('Cannot start the workflow.') return r['runId']