async def main():
context = RootContext()
props = Props.from_producer(HelloActor)
pid = context.spawn(props)
await context.send(pid, HelloMessage('Hello World!'))
input()
async def run_round_robin_pool_test():
context = RootContext()
props = Router.new_round_robin_pool(my_actor_props, 5)
pid = context.spawn(props)
for i in range(10):
await context.send(pid, Message('%s' % (i % 4)))
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 run_broadcast_pool_test():
context = RootContext()
props = Router.new_broadcast_pool(my_actor_props, 5)
for i in range(10):
pid = context.spawn(props)
await context.send(pid, Message('%s' % (i % 4)))
async def test_can_use_global_behaviour():
context = RootContext()
test_actor_props = Props.from_producer(LightBulb)
actor = context.spawn(test_actor_props)
_ = await context.request_async(actor, PressSwitch())
assert await context.request_async(actor, HitWithHammer()) == "Smashed!"
assert await context.request_async(actor, PressSwitch()) == "Broken"
assert await context.request_async(actor, Touch()) == "OW!"
async def test_can_change_states():
test_actor_props = Props.from_producer(LightBulb)
context = RootContext()
actor = context.spawn(test_actor_props)
assert await context.request_async(actor, PressSwitch()) == "Turning on"
assert await context.request_async(actor, Touch())== "Hot!"
assert await context.request_async(actor, PressSwitch()) == "Turning off"
assert await context.request_async(actor, Touch()) == "Cold"
async def run_random_group_test():
context = RootContext()
props = Router.new_random_group([
context.spawn(my_actor_props),
context.spawn(my_actor_props),
context.spawn(my_actor_props),
context.spawn(my_actor_props)
])
pid = context.spawn(props)
for i in range(10):
await context.send(pid, Message('%s' % (i % 4)))
async def start(argv):
host = None
port = None
opts, args = getopt.getopt(argv, "hp", ["host=", "port="])
for opt, arg in opts:
if opt == '--host':
host = arg
elif opt == '--port':
port = arg
Serialization().register_file_descriptor(DESCRIPTOR)
context = RootContext()
Remote().start(host, port)
props = Props().from_producer(lambda: EchoActor(host, port))
Remote().register_known_kind('EchoActor', props)
context.spawn_named(props, "EchoActorInstance")
input()
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_async(pid, "number")
reply_after_push = await context.request_async(pid, None)
reply_after_pop = await context.request_async(pid, "answertolifetheuniverseandeverything")
assert reply + str(reply_after_push) + reply_after_pop == "number42answertolifetheuniverseandeverything"
from datetime import timedelta
import pytest
from protoactor.actor.actor import RootContext, Actor, AbstractContext
from protoactor.actor.props import Props
from protoactor.router.messages import RemoveRoutee, GetRoutees, AddRoutee, BroadcastMessage
from protoactor.router.router import Router
from tests.test_fixtures.test_mailbox import MockMailbox
context = RootContext()
timeout = timedelta(milliseconds=1000)
my_actor_props = Props.from_producer(lambda: MyTestActor()).with_mailbox(
MockMailbox)
@pytest.mark.asyncio
async def test_round_robin_group_router_routees_receive_messages_in_round_robin_style(
):
router, routee1, routee2, routee3 = create_router_with3_routees()
await context.send(router, '1')
# only routee1 has received the message
assert await context.request_async(routee1, 'received?', timeout) == '1'
assert await context.request_async(routee2, 'received?', timeout) is None
assert await context.request_async(routee3, 'received?', timeout) is None
await context.send(router, '2')
await context.send(router, '3')
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_async(pid, "hello")
print('Got result ' + res)
await asyncio.sleep(0.5)
import sys
import threading
import uuid
from datetime import timedelta
import pytest
from protoactor.actor.actor import RootContext, Actor, AbstractContext
from protoactor.actor.messages import Started
from protoactor.actor.props import Props
from protoactor.persistence.persistence import Persistence
from tests.persistence.in_memory_provider import InMemoryProvider
from tests.test_fixtures.mock_mailbox import MockMailbox
root_context = RootContext()
initial_state = 1
@pytest.mark.asyncio
async def test_events_are_saved_to_persistence():
def callback(o):
assert isinstance(o, Multiplied)
assert o.amount == 2
_, pid, _, actor_id, provider_state = create_test_actor()
await root_context.send(pid, Multiply(2))
await provider_state.get_events(actor_id, 0, sys.maxsize, callback)
@pytest.mark.asyncio
async def test_snapshots_are_saved_to_persistence():