async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting("blah-blah-blah")
assert GreetingWorkflowImpl.argument1 == "blah-blah-blah"
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
return_value = await greeting_workflow.get_greeting()
assert return_value == "from-workflow"
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
options = WorkflowOptions()
options.workflow_id = "blah" + str(datetime.now())
options.workflow_id_reuse_policy = (
WorkflowIdReusePolicy.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE)
options.workflow_execution_timeout = timedelta(seconds=1000)
options.workflow_run_timeout = timedelta(seconds=500)
options.workflow_task_timeout = timedelta(seconds=30)
options.memo = {"name": "bob"}
options.search_attributes = {}
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow, workflow_options=options)
await greeting_workflow.get_greeting()
request = GetWorkflowExecutionHistoryRequest(
namespace=NAMESPACE,
execution=WorkflowExecution(workflow_id=options.workflow_id),
)
response = await client.service.get_workflow_execution_history(
request=request)
attr = response.history.events[
0].workflow_execution_started_event_attributes
assert attr.workflow_execution_timeout == timedelta(seconds=1000)
assert attr.workflow_run_timeout == timedelta(seconds=500)
assert attr.workflow_task_timeout == timedelta(seconds=30)
assert attr.memo.fields["name"].data == b'"bob"'
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting()
assert isinstance(workflow_id, str)
assert isinstance(run_id, str)
async def test_workflow_workflow_get_version():
global v1_hits, v2_hits
client: WorkflowClient = WorkflowClient.new_client("localhost",
7233,
namespace=NAMESPACE)
factory = WorkerFactory(client, NAMESPACE)
worker = factory.new_worker(TASK_QUEUE)
worker.register_workflow_implementation_type(TestWorkflowGetVersionImplV1)
factory.start()
workflow: TestWorkflowGetVersion = client.new_workflow_stub(
TestWorkflowGetVersion)
await client.start(workflow.get_greetings)
while v1_hits == 0:
print(".", end="")
await asyncio.sleep(2)
worker.register_workflow_implementation_type(TestWorkflowGetVersionImplV2)
while not v2_done:
print(".", end="")
await asyncio.sleep(2)
assert v1_hits == 1
assert v2_hits == 1
assert version_found_in_v2_step_1_0 == DEFAULT_VERSION
assert version_found_in_v2_step_1_1 == DEFAULT_VERSION
assert version_found_in_v2_step_2_0 == DEFAULT_VERSION
assert version_found_in_v2_step_2_1 == DEFAULT_VERSION
# TODO: Assert that there are no markers recorded
await cleanup_worker(client, worker)
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting()
assert GreetingActivitiesImpl.activity_method_executed
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting()
request = GetWorkflowExecutionHistoryRequest(
namespace=NAMESPACE,
execution=WorkflowExecution(workflow_id=workflow_id))
response = await client.service.get_workflow_execution_history(
request=request)
e = next(
filter(
lambda v: v.event_type == EventType.
EVENT_TYPE_ACTIVITY_TASK_SCHEDULED, response.history.events))
assert e.activity_task_scheduled_event_attributes.schedule_to_close_timeout == timedelta(
seconds=1000)
assert e.activity_task_scheduled_event_attributes.schedule_to_start_timeout == timedelta(
seconds=500)
assert e.activity_task_scheduled_event_attributes.start_to_close_timeout == timedelta(
seconds=800)
assert e.activity_task_scheduled_event_attributes.heartbeat_timeout == timedelta(
seconds=600)
assert e.activity_task_scheduled_event_attributes.retry_policy.initial_interval == timedelta(
seconds=70)
assert e.activity_task_scheduled_event_attributes.retry_policy.backoff_coefficient == 5.0
assert e.activity_task_scheduled_event_attributes.retry_policy.maximum_interval == timedelta(
seconds=700)
assert e.activity_task_scheduled_event_attributes.retry_policy.maximum_attempts == 8
assert e.activity_task_scheduled_event_attributes.retry_policy.non_retryable_error_types == [
"DummyError"
]
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
ret_value = await greeting_workflow.get_greeting()
assert ret_value == 199
assert activity_invocation_count == 200
async def fn():
client = WorkflowClient.new_client(namespace=NAMESPACE)
activity_completion_client = client.new_activity_completion_client()
print(f"Sleeping for {sleep_seconds} seconds")
await asyncio.sleep(sleep_seconds)
await activity_completion_client.complete(task_token, sleep_seconds)
client.close()
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
await greeting_workflow.get_greeting("first-argument", "second-argument")
assert GreetingWorkflowImpl.argument1 == "first-argument"
assert GreetingWorkflowImpl.argument2 == "second-argument"
async def fn():
client = WorkflowClient.new_client(namespace=NAMESPACE)
activity_completion_client = client.new_activity_completion_client()
sleep(10)
await activity_completion_client.complete_exceptionally(
task_token, GreetingException("greeting error!"))
client.close()
async def test(worker):
global workflow_started
client = WorkflowClient.new_client(namespace=NAMESPACE, data_converter=PickleDataConverter())
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
context = await WorkflowClient.start(greeting_workflow.get_greeting)
while not workflow_started:
await asyncio.sleep(2)
greeting_workflow = client.new_workflow_stub_from_workflow_id(GreetingWorkflow,
workflow_id=context.workflow_execution.workflow_id)
await greeting_workflow.push_status(SIGNAL_ARG_TYPE_1, SIGNAL_ARG_TYPE_2)
await greeting_workflow.get_status(QUERY_ARG_TYPE_1, QUERY_ARG_TYPE_2)
await client.wait_for_close(context)
assert deserialized == [
# Signal invocation
(SignalArgType1, SIGNAL_ARG_TYPE_1),
(SignalArgType2, SIGNAL_ARG_TYPE_2),
# Replay signal to invoke query
(SignalArgType1, SIGNAL_ARG_TYPE_1),
(SignalArgType2, SIGNAL_ARG_TYPE_2),
(QueryArgType1, QUERY_ARG_TYPE_1),
(QueryArgType2, QUERY_ARG_TYPE_2),
# Query return type being deserialized
(QueryRetType, QUERY_RET_TYPE),
# Workflow replayed after sleep is over
(SignalArgType1, SIGNAL_ARG_TYPE_1),
(SignalArgType2, SIGNAL_ARG_TYPE_2)
]
async def fn():
client = WorkflowClient.new_client(namespace=NAMESPACE)
activity_completion_client = client.new_activity_completion_client()
sleep(10)
return_value = "from-activity-completion-client"
await activity_completion_client.complete(task_token, return_value)
client.close()
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
ret_value = await greeting_workflow.get_greeting()
assert ret_value == HEARTBEAT_VALUE
assert captured_heartbeat_value == HEARTBEAT_VALUE
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
start_time = time.time()
await greeting_workflow.get_greeting()
end_time = time.time()
assert end_time - start_time > 5
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE,
data_converter=PickleDataConverter())
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
ret_value = await greeting_workflow.get_greeting()
assert ret_value == Greeting("Bob", 20)
client.close()
async def test(worker):
reset_counter_filter_counter()
logging.config.dictConfig(LOGGING)
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting()
assert get_counter_filter_counter() == 5
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
await greeting_workflow.get_greeting()
assert namespace == "default"
assert task_token is not None
assert workflow_execution is not None
assert workflow_execution.workflow_id is not None
assert workflow_execution.run_id is not None
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
context = await WorkflowClient.start(greeting_workflow.get_greeting)
greeting_workflow = client.new_workflow_stub_from_workflow_id(
GreetingWorkflow, workflow_id=context.workflow_execution.workflow_id)
await greeting_workflow.hello("1", 2)
ret_value = await client.wait_for_close(context)
assert ret_value == ["1", 2]
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting()
assert version_found_in_step_1_0 == 2
assert version_found_in_step_1_1 == 2
assert version_found_in_step_2_0 == 2
assert version_found_in_step_2_1 == 2
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
await greeting_workflow.get_greeting()
assert caught_exception is not None
assert isinstance(caught_exception, ActivityFailureException)
cause = caught_exception.get_cause()
assert isinstance(cause, GreetingException)
assert cause.__traceback__ is not None
assert cause.args == ("greeting error!",)
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
caught_exception = None
try:
await greeting_workflow.get_greeting()
except GreetingException as e:
caught_exception = e
assert caught_exception
assert isinstance(caught_exception, GreetingException)
async def test(worker):
global signal_invoked
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
context = await WorkflowClient.start(greeting_workflow.get_greeting)
greeting_workflow = client.new_workflow_stub_from_workflow_id(
GreetingWorkflow, workflow_id=context.workflow_execution.workflow_id)
await greeting_workflow.hello()
await client.wait_for_close(context)
assert signal_invoked
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
start_time = time.time()
await greeting_workflow.get_greeting()
end_time = time.time()
assert 5 < end_time - start_time < 50
assert len(done) == 1
assert done[0] is timer
client.close()
async def test(worker):
global a, b, c
a, b, c = [], [], []
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
await greeting_workflow.get_greeting()
assert len(a) >= 4 and len(set(a)) == 1
assert len(b) >= 3 and len(set(b)) == 1
assert len(c) >= 2 and len(set(c)) == 1
assert len(set(itertools.chain(a, b, c))) == 3
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
await greeting_workflow.get_greeting()
request = GetWorkflowExecutionHistoryRequest(
namespace=NAMESPACE, execution=WorkflowExecution(workflow_id=workflow_id)
)
response = await client.service.get_workflow_execution_history(request=request)
attr = response.history.events[0].workflow_execution_started_event_attributes
assert attr.workflow_execution_timeout == timedelta(seconds=1000)
assert attr.workflow_run_timeout == timedelta(seconds=500)
assert attr.workflow_task_timeout == timedelta(seconds=30)
assert attr.memo.fields["name"].data == b'"bob"'
async def client_main():
# ENG
# 1- We create the new client
# 2- We create el workflow stub
# 3- We invoke the workflow method and wait for the result.
# SPA
# 1- Creamos el nuevo cliente
# 2- Creamos el workflow subordinado/avatar(objeto remoto que tiene la interface del worklow)
# 3- Invocamos el método workflow y esperamos por el resultado.
client = WorkflowClient.new_client(namespace=NAMESPACE)
qa_workflow: QAWorkflow = client.new_workflow_stub(QAWorkflow)
result = await qa_workflow.apply_qa(
"What's your name? / Cual es tu nombre?", "Hernan Moreno")
print(result)
async def test(worker):
global await_returned
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
context = await WorkflowClient.start(greeting_workflow.get_greeting)
greeting_workflow = client.new_workflow_stub_from_workflow_id(GreetingWorkflow,
workflow_id=context.workflow_execution.workflow_id)
await greeting_workflow.send_message("first")
await asyncio.sleep(1)
await greeting_workflow.send_message("second")
await asyncio.sleep(1)
await greeting_workflow.send_message("done")
await client.wait_for_close(context)
assert await_returned
async def test(worker):
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(GreetingWorkflow)
context: WorkflowExecutionContext = await client.start(
greeting_workflow.get_greeting
)
await asyncio.sleep(60 * 3)
assert invoke_count >= 2
request = TerminateWorkflowExecutionRequest()
request.namespace = NAMESPACE
request.identity = get_identity()
request.workflow_execution = context.workflow_execution
request.workflow_execution.run_id = None
response: TerminateWorkflowExecutionResponse = (
await client.service.terminate_workflow_execution(request=request)
)
async def test(worker):
global workflow_started
client = WorkflowClient.new_client(namespace=NAMESPACE)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
context = await WorkflowClient.start(greeting_workflow.get_greeting)
greeting_workflow = client.new_workflow_stub_from_workflow_id(
GreetingWorkflow, workflow_id=context.workflow_execution.workflow_id)
while not workflow_started:
await asyncio.sleep(2)
status = await greeting_workflow.get_status()
assert status == "STARTED"
status = await greeting_workflow.get_status_as_list()
assert status == ["STARTED"]
status = await greeting_workflow.get_status_as_list_with_args("1", "2")
assert status == ["STARTED", "1", "2"]
await client.wait_for_close(context)