def new_client(cls, host: str = "localhost", port: int = 7933, domain: str = "", options: WorkflowClientOptions = None) -> WorkflowClient: service = WorkflowService.create(host, port) return cls(service=service, domain=domain, options=options)
def run(self): try: logger.info( f"Decision task worker started: {WorkflowService.get_identity()}" ) event_loop = asyncio.new_event_loop() asyncio.set_event_loop(event_loop) self.service = WorkflowService.create(self.worker.host, self.worker.port) self.worker.manage_service(self.service) while True: if self.worker.is_stop_requested(): return decision_task: PollForDecisionTaskResponse = self.poll() if not decision_task: continue if decision_task.query: try: result = self.process_query(decision_task) self.respond_query(decision_task.task_token, result, None) except Exception as ex: logger.error("Error") self.respond_query(decision_task.task_token, None, serialize_exception(ex)) else: decisions = self.process_task(decision_task) self.respond_decisions(decision_task.task_token, decisions) finally: # noinspection PyPep8,PyBroadException try: self.service.close() except: logger.warning("service.close() failed", exc_info=1) self.worker.notify_thread_stopped()
def new_client( cls, host: str = "localhost", port: int = 7933, domain: str = "", options: WorkflowClientOptions = None, timeout: int = DEFAULT_SOCKET_TIMEOUT_SECONDS) -> WorkflowClient: service = WorkflowService.create(host, port, timeout=timeout) return cls(service=service, domain=domain, options=options)
def setUp(self) -> None: self.service = WorkflowService.create("localhost", 7933) self.request = request = StartWorkflowExecutionRequest() request.domain = "test-domain" request.request_id = str(uuid4()) request.task_list = TaskList() request.task_list.name = "test-task-list" request.input = "abc-firdaus" request.workflow_id = str(uuid4()) request.workflow_type = WorkflowType() request.workflow_type.name = "firdaus-workflow-type" request.execution_start_to_close_timeout_seconds = 86400 request.task_start_to_close_timeout_seconds = 120 time.sleep(0.5)
def activity_task_loop(worker: Worker): service: WorkflowService = WorkflowService.create( worker.host, worker.port, timeout=worker.get_timeout()) worker.manage_service(service) logger.info( f"Activity task worker started: {WorkflowService.get_identity()}") try: while True: if worker.is_stop_requested(): return try: service.set_next_timeout_cb(worker.raise_if_stop_requested) polling_start = datetime.datetime.now() polling_request = PollForActivityTaskRequest() polling_request.task_list_metadata = TaskListMetadata() polling_request.task_list_metadata.max_tasks_per_second = 200000 polling_request.domain = worker.domain polling_request.identity = WorkflowService.get_identity() polling_request.task_list = TaskList() polling_request.task_list.name = worker.task_list task: PollForActivityTaskResponse task, err = service.poll_for_activity_task(polling_request) polling_end = datetime.datetime.now() logger.debug("PollForActivityTask: %dms", (polling_end - polling_start).total_seconds() * 1000) except StopRequestedException: return except Exception as ex: logger.error("PollForActivityTask error: %s", ex) continue if err: logger.error("PollForActivityTask failed: %s", err) continue task_token = task.task_token if not task_token: logger.debug( "PollForActivityTask has no task_token (expected): %s", task) continue args = json_to_args(task.input) logger.info(f"Request for activity: {task.activity_type.name}") fn = worker.activities.get(task.activity_type.name) if not fn: logger.error("Activity type not found: " + task.activity_type.name) continue process_start = datetime.datetime.now() activity_context = ActivityContext() activity_context.service = service activity_context.activity_task = ActivityTask.from_poll_for_activity_task_response( task) activity_context.domain = worker.domain try: ActivityContext.set(activity_context) return_value = fn(*args) if activity_context.do_not_complete: logger.info( f"Not completing activity {task.activity_type.name}({str(args)[1:-1]})" ) continue error = complete(service, task_token, return_value) if error: logger.error( "Error invoking RespondActivityTaskCompleted: %s", error) logger.info( f"Activity {task.activity_type.name}({str(args)[1:-1]}) returned {json.dumps(return_value)}" ) except Exception as ex: logger.error( f"Activity {task.activity_type.name} failed: {type(ex).__name__}({ex})", exc_info=1) error = complete_exceptionally(service, task_token, ex) if error: logger.error( "Error invoking RespondActivityTaskFailed: %s", error) finally: ActivityContext.set(None) process_end = datetime.datetime.now() logger.info("Process ActivityTask: %dms", (process_end - process_start).total_seconds() * 1000) finally: try: service.close() except: logger.warning("service.close() failed", exc_info=1) worker.notify_thread_stopped()
def activity_task_loop(worker): service = WorkflowService.create(worker.host, worker.port) logger.info( f"Activity task worker started: {WorkflowService.get_identity()}") try: while True: if worker.is_stop_requested(): return try: polling_start = datetime.datetime.now() polling_request = PollForActivityTaskRequest() polling_request.task_list_metadata = TaskListMetadata() polling_request.task_list_metadata.max_tasks_per_second = 200000 polling_request.domain = worker.domain polling_request.identity = WorkflowService.get_identity() polling_request.task_list = TaskList() polling_request.task_list.name = worker.task_list task: PollForActivityTaskResponse task, err = service.poll_for_activity_task(polling_request) polling_end = datetime.datetime.now() logger.debug("PollForActivityTask: %dms", (polling_end - polling_start).total_seconds() * 1000) except Exception as ex: logger.error("PollForActivityTask error: %s", ex) continue if err: logger.error("PollForActivityTask failed: %s", err) continue if not task.task_token: logger.debug( "PollForActivityTask has no task_token (expected): %s", task) continue args = json.loads(task.input) logger.info(f"Request for activity: {task.activity_type.name}") fn = worker.activities.get(task.activity_type.name) if not fn: logger.error("Activity type not found: " + task.activity_type.name) continue process_start = datetime.datetime.now() try: ret = fn(*args) respond = RespondActivityTaskCompletedRequest() respond.task_token = task.task_token respond.result = json.dumps(ret) respond.identity = WorkflowService.get_identity() _, error = service.respond_activity_task_completed(respond) if error: logger.error( "Error invoking RespondActivityTaskCompleted: %s", error) logger.info( f"Activity {task.activity_type.name}({str(args)[1:-1]}) returned {respond.result}" ) except Exception as ex: logger.error( f"Activity {task.activity_type.name} failed: {type(ex).__name__}({ex})", exc_info=1) respond: RespondActivityTaskFailedRequest = RespondActivityTaskFailedRequest( ) respond.task_token = task.task_token respond.identity = WorkflowService.get_identity() respond.details = json.dumps({ "detailMessage": f"Python error: {type(ex).__name__}({ex})", "class": "java.lang.Exception" }) respond.reason = "java.lang.Exception" _, error = service.respond_activity_task_failed(respond) if error: logger.error( "Error invoking RespondActivityTaskFailed: %s", error) process_end = datetime.datetime.now() logger.info("Process ActivityTask: %dms", (process_end - process_start).total_seconds() * 1000) finally: worker.notify_thread_stopped()
import json from cadence.cadence_types import GetWorkflowExecutionHistoryRequest, WorkflowExecution from cadence.workflowservice import WorkflowService class Encoder(json.JSONEncoder): def default(self, o): if dataclasses.is_dataclass(o): return dataclasses.asdict(o) if isinstance(o, bytes): return str(o, 'utf-8') return super().default(o) if __name__ == "__main__": service = WorkflowService.create("localhost", 7933) history_request = GetWorkflowExecutionHistoryRequest() history_request.domain = "sample" history_request.execution = WorkflowExecution() history_request.execution.workflow_id = sys.argv[1] history_request.maximum_page_size = 100 history_response, err = service.get_workflow_execution_history( history_request) if err: print(err) else: print(json.dumps(history_response, cls=Encoder, indent=2))