async def start(argv):
tracer = init_jaeger_tracer()
opentracing.set_global_tracer(tracer)
middleware = open_tracing_middleware.open_tracing_sender_middleware(tracer)
Serialization().register_file_descriptor(DESCRIPTOR)
Remote().start("127.0.0.1", 12001)
server = PID(address='127.0.0.1:8000', id='chatserver')
context = RootContext(MessageHeader(), [middleware])
props = OpenTracingFactory.get_props_with_open_tracing(Props.from_func(process_message), span_setup, span_setup,
tracer)
client = context.spawn(props)
await context.send(server, Connect(sender=client))
nick = 'Alex'
while True:
text = input()
if text == '/exit':
return
elif text.startswith('/nick '):
new_nick = text.split(' ')[1]
await context.send(server, NickRequest(old_user_name=nick, new_user_name=new_nick))
nick = new_nick
else:
await context.send(server, SayRequest(user_name=nick, message=text))
async def main():
context = RootContext()
props = Props.from_func(hello_function)
pid = context.spawn(props)
reply = await context.request_async(pid, HelloMessage('Hello'))
print(reply)
async def test_reenter_after_can_do_action_for_task():
queue = Queue()
async def actor(ctx):
if ctx.message == 'hello1':
async def target():
await asyncio.sleep(0.1)
queue.put('bar')
return 'hey1'
async def action(result):
queue.put('baz')
await ctx.respond(result)
ctx.reenter_after(target, action)
elif ctx.message == 'hello2':
queue.put('foo')
await ctx.respond('hey2')
props = Props.from_func(actor)
pid = context.spawn(props)
task1 = asyncio.ensure_future(context.request_async(pid, "hello1"))
task2 = asyncio.ensure_future(context.request_async(pid, "hello2"))
reply1 = await task1
reply2 = await task2
assert reply1 == 'hey1'
assert reply2 == 'hey2'
assert 'foo' == queue.get()
assert 'bar' == queue.get()
assert 'baz' == queue.get()
async def main():
tracer = init_jaeger_tracer()
opentracing.set_global_tracer(tracer)
context = RootContext()
Serialization().register_file_descriptor(DESCRIPTOR)
Remote().start("127.0.0.1", 8000)
clients = []
async def process_message(ctx: AbstractContext):
msg = ctx.message
if isinstance(msg, Connect):
print(f'Client {msg.sender} connected')
clients.append(msg.sender)
await ctx.send(msg.sender, Connected(message='Welcome!'))
elif isinstance(msg, SayRequest):
for client in clients:
await ctx.send(client, SayResponse(user_name=msg.user_name, message=msg.message))
elif isinstance(msg, NickRequest):
for client in clients:
await ctx.send(client, NickResponse(old_user_name=msg.old_user_name, new_user_name=msg.new_user_name))
props = OpenTracingFactory.get_props_with_open_tracing(Props.from_func(process_message), span_setup, span_setup)
context.spawn_named(props, 'chatserver')
input()
async def test_request_actor_async_should_not_raise_timeout_exception_when_result_is_first(
):
props = Props.from_func(hello_function)
pid = context.spawn(props)
reply = await context.request_async(pid, "hello", timedelta(seconds=1))
assert reply == "hey"
async def test_pop_behavior_should_restore_pushed_behavior():
behavior = Behavior()
async def func_1(ctx):
if isinstance(ctx.message, str):
async def func_2(ctx2):
await ctx2.respond(42)
behavior.unbecome_stacked()
behavior.become_stacked(func_2)
await ctx.respond(ctx.message)
behavior.become(func_1)
props = Props.from_func(behavior.receive_async)
context = RootContext()
pid = context.spawn(props)
reply = await context.request_future(pid, "number")
reply_after_push = await context.request_future(pid, None)
reply_after_pop = await context.request_future(
pid, "answertolifetheuniverseandeverything")
assert reply + str(
reply_after_push
) + reply_after_pop == "number42answertolifetheuniverseandeverything"
async def run_test(mailbox: Callable[..., AbstractMailbox]):
props = Props.from_func(process_message) \
.with_mailbox(mailbox)
pid = GlobalRootContext.spawn(props)
for i in range(10000):
await GlobalRootContext.send(pid, i)
await GlobalRootContext.request_future(pid, 'stop')
async def test_request_actor_async_should_raise_timeout_exception_when_timeout_is_reached(
):
with pytest.raises(TimeoutError) as excinfo:
props = Props.from_func(empty_receive)
pid = context.spawn(props)
await context.request_async(pid, "", timedelta(seconds=1))
assert 'TimeoutError' in str(excinfo)
async def main():
async def child_fn(context: AbstractContext):
print(f'{context.my_self.id}: MSG: {type(context.message)}')
if isinstance(context.message, Started):
raise Exception('child failure')
child_props = Props.from_func(child_fn)
async def root_fn(context: AbstractContext):
print(f'{context.my_self.id}: MSG: {type(context.message)}')
if isinstance(context.message, Started):
context.spawn_named(child_props, 'child')
elif isinstance(context.message, Terminated):
print(f'Terminated {context.message.who}')
root_props = Props.from_func(root_fn).with_child_supervisor_strategy(
OneForOneStrategy(lambda pid, reason: SupervisorDirective.Escalate, 0,
None))
root_context = RootContext()
root_context.spawn_named(root_props, 'root')
input()
async def main():
context = LoggingRootDecorator(RootContext())
async def fn(context: AbstractContext):
message = context.message
if isinstance(message, str):
print(f'Inside Actor: {message}')
await context.respond("Yo!")
props = Props.from_func(fn).with_context_decorator([
lambda c: LoggingDecorator(c, 'logger1'),
lambda c: LoggingDecorator(c, 'logger2')
])
pid = context.spawn(props)
res = await context.request_future(pid, 'Hello')
print(f'Got result {res}')
input()
async def main():
root_context = RootContext()
counter = itertools.count()
next(counter)
async def fn(context: AbstractContext):
msg = context.message
if isinstance(msg, Started):
print(f'{datetime.today().strftime("%Y-%m-%d-%H.%M.%S")} Started')
context.set_receive_timeout(timedelta(seconds=1))
elif isinstance(msg, ReceiveTimeout):
print(f'{datetime.today().strftime("%Y-%m-%d-%H.%M.%S")} ReceiveTimeout: {next(counter)}')
elif isinstance(msg, NoInfluence):
print(f'{datetime.today().strftime("%Y-%m-%d-%H.%M.%S")} Received a no-influence message')
elif isinstance(msg, str):
print(f'{datetime.today().strftime("%Y-%m-%d-%H.%M.%S")} Received message: {msg}')
props = Props.from_func(fn)
pid = root_context.spawn(props)
for i in range(6):
await root_context.send(pid, 'hello')
await asyncio.sleep(0.5)
print('Hit [return] to send no-influence messages')
input()
for i in range(6):
await root_context.send(pid, NoInfluence())
await asyncio.sleep(0.5)
print('Hit [return] to send a message to cancel the timeout')
input()
await root_context.send(pid, 'cancel')
print('Hit [return] to finish')
input()
async def start(argv):
Serialization().register_file_descriptor(DESCRIPTOR)
async def fn(ctx: AbstractContext):
if isinstance(ctx.message, HelloRequest):
await ctx.respond(HelloResponse(message='Hello from node 2'))
props = Props.from_func(fn)
parsed_args = parse_args(argv)
Remote().register_known_kind("HelloKind", props)
# await Cluster.start('MyCluster', parsed_args.server_name, 12000,
# SingleRemoteInstanceProvider(parsed_args.server_name, 12000))
await Cluster.start(
'MyCluster', parsed_args.server_name, 12000,
ConsulProvider(
ConsulClientConfiguration(
f'http://{parsed_args.consul_url}:8500/')))
await asyncio.sleep(timedelta(days=180).total_seconds())
print('Shutting Down...')
await Cluster.shutdown()
def __init__(self, server_host: str, server_port: int):
self._kinds_responder = 'remote_kinds_responder'
self._timeout = timedelta(seconds=10)
self._server_host = server_host
self._server_port = server_port
self._server_address = '%s:%s' % (server_host, str(server_port))
self._kinds = []
self._ok_status = None
self._ko_status = None
self._is_server = None
self._shutdown = None
async def fn(ctx: AbstractContext):
if isinstance(ctx.message, GetKinds) and ctx.sender is not None:
await ctx.respond(GetKindsResponse(kinds=self._kinds))
props = Props.from_func(fn)
Serialization().register_file_descriptor(DESCRIPTOR)
Remote().register_known_kind(self._kinds_responder, props)
async def main():
headers = MessageHeader({'TraceID': str(uuid.uuid4()),
'SpanID': str(uuid.uuid4())})
def get_middleware(next_middleware):
async def process(context, target, envelope):
new_envelope = envelope \
.with_header(key='TraceID', value=context.headers.get('TraceID')) \
.with_header(key='SpanID', value=str(uuid.uuid4())) \
.with_header(key='ParentSpanID', value=context.headers.get('SpanID'))
print(' 1 Enter RootContext SenderMiddleware')
print(' 1 TraceID: ' + new_envelope.header.get('TraceID'))
print(' 1 SpanID: ' + new_envelope.header.get('SpanID'))
print(' 1 ParentSpanID: ' + new_envelope.header.get('ParentSpanID'))
await next_middleware(context, target, new_envelope)
print(' 1 Exit RootContext SenderMiddleware - Send is async, this is out of order by design')
return process
root = RootContext(headers, [get_middleware])
async def actor_logic(context):
if isinstance(context.message, str):
print(' 3 Enter Actor')
print(' 3 TraceID = ' + context.headers.get('TraceID'))
print(' 3 SpanID = ' + context.headers.get('SpanID'))
print(' 3 ParentSpanID = ' + context.headers.get('ParentSpanID'))
print(' 3 actor got = %s:%s' % (str(type(context.message)), context.message))
await context.respond("World !")
print(' 3 Exit Actor')
def get_receive_middleware(next_middleware):
async def process(context, envelope):
if isinstance(envelope.message, str):
new_envelope = envelope \
.with_header(key='TraceID', value=envelope.header.get('TraceID')) \
.with_header(key='SpanID', value=str(uuid.uuid4())) \
.with_header(key='ParentSpanID', value=envelope.header.get('SpanID'))
print(' 2 Enter Actor ReceiverMiddleware')
print(' 2 TraceID: ' + new_envelope.header.get('TraceID'))
print(' 2 SpanID: ' + new_envelope.header.get('SpanID'))
print(' 2 ParentSpanID: ' + new_envelope.header.get('ParentSpanID'))
await next_middleware(context, new_envelope)
print(' 2 Exit Actor ReceiverMiddleware')
else:
await next_middleware(context, envelope)
return process
def get_sender_middleware(next_middleware):
async def process(context, target, envelope):
new_envelope = envelope \
.with_header(key='TraceID', value=context.headers.get('TraceID')) \
.with_header(key='SpanID', value=str(uuid.uuid4())) \
.with_header(key='ParentSpanID', value=context.headers.get('SpanID'))
print(' 4 Enter Actor SenderMiddleware')
print(' 4 TraceID: ' + new_envelope.header.get('TraceID'))
print(' 4 SpanID: ' + new_envelope.header.get('SpanID'))
print(' 4 ParentSpanID: ' + new_envelope.header.get('ParentSpanID'))
await next_middleware(context, target, envelope)
print(' 4 Exit Actor SenderMiddleware')
return process
actor = Props.from_func(actor_logic)\
.with_receive_middleware([get_receive_middleware])\
.with_sender_middleware([get_sender_middleware])
pid = root.spawn(actor)
print('0 TraceID: ' + root.headers.get('TraceID'))
print('0 SpanID: ' + root.headers.get('SpanID'))
print('0 ParentSpanID: ' + root.headers.get('ParentSpanID', ''))
res = await root.request_future(pid, "hello")
print('Got result ' + res)
await asyncio.sleep(0.5)
async def test_request_actor_async():
props = Props.from_func(hello_function)
pid = context.spawn(props)
reply = await context.request_async(pid, "hello")
assert reply == "hey"
