comotore 19.12.2

comotore - component engine library - simple actor model realisation

Comotore - component engine library - simple actor model realisation.

Examples

Client/server example

import asyncio
import logging
import sys

from comotore import (Engine, Component)
from comotore.logging.formatters import PlainFormatter
from comotore import runner


class Client(Component):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self._name = kwargs.get("name", None)

    async def construct(self):
        async def process():
            req = await self.request("{name}".format(name=self._name))
            async for res in req.response():
                self.logger["Client"].info(
                    "Response {name}".format(name=self._name), corr_id=req.correlation_id, payload=res
                )
            self.logger["Client"].info("Responses completed {name}".format(name=self._name))
            await self.completed()

        self.fly(process())

    @Component.signal
    def request(self, data):
        pass

    @Component.signal
    def completed(self, _):
        pass


class Server(Component):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        self._name = kwargs.get("name", None)

    async def response(self, request):
        self.logger["Server"].info("Request", payload=request.payload)
        for i in range(2):
            yield "{name} {payload} {number}".format(name=self._name, payload=request.payload, number=i)
            await asyncio.sleep(1)


async def main():
    engine = Engine()

    engine.logger.setLevel(logging.INFO)
    handler = logging.StreamHandler(sys.stderr)
    formatter = PlainFormatter(
        "{asctime} - {levelname}: [{tag}] hostname={hostname}, pid={process}, tid={thread}> {message} {data}", style="{"
    )
    handler.setFormatter(formatter)
    engine.logger.addHandler(handler)

    server_first = engine.component(Server, name="first")
    server_second = engine.component(Server, name="second")
    client = engine.component(
        Client, name="client_1",
        start_waiting_for=[server_first.started, server_second.started]
    )
    engine.call(client.request, server_first.response)
    engine.call(client.request, server_second.response)
    engine.cast(client.completed, engine.avatar.quit)

    print(engine)
    print("-" * 40)
    await engine

if __name__ == "__main__":
    runner.run(main())

Producer/consumer example

import asyncio
import logging
import uuid
import sys

from comotore import (Engine, Component)
from comotore.logging.formatters import PlainFormatter
from comotore import runner


class Producer(Component):
    async def construct(self):
        async def produce():
            try:
                i = 0
                while True:
                    payload = uuid.uuid4()
                    await self.produced(payload)
                    self.logger["Producer"].info("Produce", payload=payload)
                    await asyncio.sleep(2)
                    i += 1
                    if i > 2:
                        break
                await self.completed()
            except asyncio.CancelledError:
                pass

        self.fly(produce())

    @Component.signal
    def produced(self, uniq_id):
        pass

    @Component.signal
    def completed(self, _):
        pass


class Consumer(Component):
    async def consume1(self, signal):
        self.logger["Consumer"].info("Consume 1", payload=signal.payload)

    async def consume2(self, signal):
        self.logger["Consumer"].info("Consume 2", payload=signal.payload)


async def main():
    engine = Engine()

    engine.logger.setLevel(logging.INFO)
    handler = logging.StreamHandler(sys.stderr)
    formatter = PlainFormatter(
        "{asctime} - {levelname}: [{tag}] hostname={hostname}, pid={process}, tid={thread}> {message} {data}", style="{"
    )
    handler.setFormatter(formatter)
    engine.logger.addHandler(handler)

    consumer = engine.component(Consumer)
    producer = engine.component(Producer, start_waiting_for=[consumer.started])
    engine.cast(producer.produced, consumer.consume1)
    engine.cast(producer.produced, consumer.consume2)
    engine.cast(producer.completed, engine.avatar.quit)

    print(engine)
    print("-" * 40)
    await engine

if __name__ == "__main__":
    runner.run(main())

Invoke example

import asyncio
import logging
import sys

from comotore import (Engine, Component)
from comotore.logging.formatters import PlainFormatter
from comotore import runner


class Worker(Component):
    @Component.signal
    def completed(self):
        pass

    async def cast_work(self, signal):
        self.logger["Worker"].info("Cast work was invoked with", payload=signal.payload)
        await self.completed()

    async def call_work(self, signal):
        self.logger["Worker"].info("Call work was invoked with", payload=signal.payload)
        for i in range(2):
            yield "Call work response {number}".format(number=i)
            await asyncio.sleep(1)


async def invoker(eng, cast_target, call_target):
    eng.logger["Invoker"].info("Invoke in 2 seconds")
    await asyncio.sleep(2)
    eng.logger["Invoker"].info("Invoke call")
    req = await eng.invoke_call(call_target, payload="Some call data")
    async for res in req.response():
        eng.logger["Invoker"].info(res)
    await eng.invoke_cast(cast_target, payload="Some cast data")


async def main():
    engine = Engine()

    engine.logger.setLevel(logging.INFO)
    handler = logging.StreamHandler(sys.stderr)
    formatter = PlainFormatter(
        "{asctime} - {levelname}: [{tag}] hostname={hostname}, pid={process}, tid={thread}> {message} {data}", style="{"
    )
    handler.setFormatter(formatter)
    engine.logger.addHandler(handler)

    worker = engine.component(Worker)
    engine.cast(worker.completed, engine.avatar.quit)

    print(engine)
    print("-" * 40)
    asyncio.ensure_future(invoker(engine, worker.cast_work, worker.call_work), loop=engine.loop)
    await engine

if __name__ == "__main__":
    runner.run(main())