def heartbeat(service: WorkflowService, task_token: bytes, details: object):
request = RecordActivityTaskHeartbeatRequest()
request.details = json.dumps(details).encode("utf-8")
request.identity = WorkflowService.get_identity()
request.task_token = task_token
response, error = service.record_activity_task_heartbeat(request)
if error:
raise error
if response.cancel_requested:
raise ActivityCancelledException()
def poll(self) -> Optional[PollForDecisionTaskResponse]:
try:
polling_start = datetime.datetime.now()
poll_decision_request = PollForDecisionTaskRequest()
poll_decision_request.identity = WorkflowService.get_identity()
poll_decision_request.task_list = TaskList()
poll_decision_request.task_list.name = self.worker.task_list
poll_decision_request.domain = self.worker.domain
# noinspection PyUnusedLocal
task: PollForDecisionTaskResponse
task, err = self.service.poll_for_decision_task(
poll_decision_request)
polling_end = datetime.datetime.now()
logger.debug("PollForDecisionTask: %dms",
(polling_end - polling_start).total_seconds() * 1000)
except TChannelException as ex:
logger.error("PollForDecisionTask error: %s", ex)
return None
if err:
logger.error("PollForDecisionTask failed: %s", err)
return None
if not task.task_token:
logger.debug(
"PollForActivityTask has no task token (expected): %s", task)
return None
return task
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) -> WorkflowClient:
service = WorkflowService.create(host, port)
return cls(service=service, domain=domain, options=options)
def complete(service, task_token, return_value: object) -> Optional[Exception]:
respond = RespondActivityTaskCompletedRequest()
respond.task_token = task_token
respond.result = json.dumps(return_value)
respond.identity = WorkflowService.get_identity()
_, error = service.respond_activity_task_completed(respond)
return error
def complete_exceptionally(service, task_token, ex: Exception) -> Optional[Exception]:
respond: RespondActivityTaskFailedRequest = RespondActivityTaskFailedRequest()
respond.task_token = task_token
respond.identity = WorkflowService.get_identity()
respond.reason = "ActivityFailureException"
respond.details = serialize_exception(ex)
_, error = service.respond_activity_task_failed(respond)
return error
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 test_poll_for_activity_task_timeout(self):
request = PollForActivityTaskRequest()
request.domain = "test-domain"
request.identity = WorkflowService.get_identity()
request.task_list = TaskList()
request.task_list.name = "test-task-list"
response, err = self.service.poll_for_activity_task(request)
self.assertIsNone(err)
self.assertIsNotNone(response)
self.assertIsNone(response.task_token)
def respond_decisions(self, task_token: bytes, decisions: List[Decision]):
service = self.service
request = RespondDecisionTaskCompletedRequest()
request.task_token = task_token
request.decisions.extend(decisions)
request.identity = WorkflowService.get_identity()
# noinspection PyUnusedLocal
response: RespondDecisionTaskCompletedResponse
response, err = service.respond_decision_task_completed(request)
if err:
logger.error("Error invoking RespondDecisionTaskCompleted: %s", err)
else:
logger.debug("RespondDecisionTaskCompleted: %s", response)
def test_heartbeat(activity_context: ActivityContext):
response = Mock()
response.cancel_requested = False
activity_context.service.record_activity_task_heartbeat = Mock(
return_value=(response, None))
activity_context.heartbeat("payload")
args, kwargs = activity_context.service.record_activity_task_heartbeat.call_args_list[
0]
assert isinstance(args[0], RecordActivityTaskHeartbeatRequest)
request: RecordActivityTaskHeartbeatRequest = args[0]
assert request.details == json.dumps("payload").encode("utf-8")
assert request.task_token == "task-token"
assert request.identity == WorkflowService.get_identity()
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))
import json
from cadence.cadence_types import PollForActivityTaskResponse, RespondActivityTaskCompletedRequest, PollForActivityTaskRequest, \
TaskList
from cadence.workflowservice import WorkflowService
service = WorkflowService.create("localhost", 7933)
while True:
task: PollForActivityTaskResponse
try:
polling_request = PollForActivityTaskRequest()
polling_request.domain = "sample"
polling_request.identity = WorkflowService.get_identity()
polling_request.task_list = TaskList()
polling_request.task_list.name = "python-tasklist"
task, error = service.poll_for_activity_task(polling_request)
except Exception as ex:
# Most probably a Timeout
continue
if error:
print("Error: " + error)
continue
print("Request: " + str(task))
input = json.loads(task.input)
greeting = input[0]
name = input[1]
output = json.dumps(greeting + " " + name + "!")
print(task.task_token)
respond_activity_completed_request = RespondActivityTaskCompletedRequest()
respond_activity_completed_request.task_token = task.task_token
