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"