def with_header(self,
header: MessageHeader = None,
key: str = None,
value: str = None):
if header is not None and key is None and value is None:
return MessageEnvelope(self.message, self.sender, header)
elif header is None and key is not None and value is not None:
message_header = self.header
if message_header is None:
message_header = MessageHeader()
header = message_header.extend(key=key, value=value)
return MessageEnvelope(self.message, self.sender, header)
else:
raise ValueError('Incorrect input value')
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))
def message_envelope():
message = "test"
sender = PID()
sender.address = "test"
sender.id = "test"
header = MessageHeader()
return MessageEnvelope(message, sender, header)
def test_create_new_message_envelope_with_header_based_on_message_header(
message_envelope):
key = "Test Key"
value = "Test Value"
message_header = MessageHeader({key: value})
envelope = message_envelope.with_header(message_header)
assert envelope.header[key] == value
def __init__(self, message_header=MessageHeader(), middleware=None):
super().__init__()
self._message = None
self._headers = message_header
if middleware is None:
self._sender_middleware = None
else:
self._sender_middleware = reduce(lambda inner, outer: outer(inner),
list(reversed(middleware)),
self.default_sender)
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)
def unwrap_header(message: Any) -> MessageHeader:
if isinstance(message, MessageEnvelope) and message.header is not None:
return message.header
return MessageHeader.empty()
def with_headers(self, items=None):
message_header = self.header
if message_header is None:
message_header = MessageHeader()
header = message_header.extend(items=items)
return MessageEnvelope(self.message, self.sender, header)