xconn 0.3.0__py3-none-any.whl

xconn/__init__.py

@@ -0,0 +1,40 @@
+from xconn.app import App, Component, register, subscribe
+from xconn.client import Client, AsyncClient
+from xconn.router import Router
+from xconn.server import Server
+from xconn.utils import run
+
+from wampproto.auth import (
+    AnonymousAuthenticator,
+    TicketAuthenticator,
+    WAMPCRAAuthenticator,
+    CryptoSignAuthenticator,
+)
+
+from wampproto.serializers import (
+    JSONSerializer,
+    MsgPackSerializer,
+    CBORSerializer,
+)
+
+__all__ = [
+    "App",
+    "Component",
+    "register",
+    "subscribe",
+    "Client",
+    "AsyncClient",
+    "Router",
+    "Server",
+    # export authenticators
+    "AnonymousAuthenticator",
+    "TicketAuthenticator",
+    "WAMPCRAAuthenticator",
+    "CryptoSignAuthenticator",
+    # export serializers
+    "JSONSerializer",
+    "MsgPackSerializer",
+    "CBORSerializer",
+    # runner for async client
+    "run",
+]

xconn/__main__.py

@@ -0,0 +1,20 @@
+import argparse
+
+from xconn._client.cli import add_client_subparser
+
+
+def main():
+    parser = argparse.ArgumentParser(description="XConn CLI")
+    subparsers = parser.add_subparsers(dest="component")
+
+    # Add subcommands from other modules
+    add_client_subparser(subparsers)
+
+    args = parser.parse_args()
+
+    if hasattr(args, "func"):
+        args.func(args)
+    elif hasattr(args, "print_help"):
+        args.print_help()
+    else:
+        parser.print_help()

xconn/_client/async_.py

@@ -0,0 +1,183 @@
+import contextlib
+import random
+import asyncio
+import inspect
+from typing import AsyncGenerator
+
+from xconn import App
+from xconn._client.helpers import (
+    _validate_procedure_function,
+    _validate_topic_function,
+    _handle_result,
+    _sanitize_incoming_data,
+    collect_docs,
+    select_authenticator,
+    start_server_async,
+    handle_model_validation,
+    ensure_caller_allowed,
+    INITIAL_WAIT,
+    MAX_WAIT,
+    ProcedureMetadata,
+    assemble_call_details,
+    assemble_event_details,
+    validate_invocation_parameters,
+    validate_event_parameters,
+)
+from xconn._client.types import ClientConfig
+from xconn.client import AsyncClient
+from xconn.async_session import AsyncSession
+from xconn.types import Event, Invocation, Result, RegisterOptions, InvokeOptions
+
+
+async def _setup(app: App, session: AsyncSession):
+    app.set_session(session)
+
+    for uri, func in app.procedures.items():
+        await register_async(session, uri, func)
+
+    for uri, func in app.topics.items():
+        await subscribe_async(session, uri, func)
+
+
+async def connect_async(app: App, config: ClientConfig, start_router: bool = False):
+    if start_router:
+        await start_server_async(config)
+
+    auth = select_authenticator(config)
+    client = AsyncClient(authenticator=auth, ws_config=config.websocket_config)
+
+    async def wait_and_connect(previous_wait: float = INITIAL_WAIT):
+        next_wait = min(random.uniform(INITIAL_WAIT, previous_wait * 3), MAX_WAIT)
+        print(f"reconnecting in {next_wait:.1f} seconds...")
+        await asyncio.sleep(next_wait)
+
+        try:
+            new_session = await client.connect(config.url, config.realm, on_connect, on_disconnect)
+        except Exception as e:
+            print(e)
+
+            await wait_and_connect(next_wait)
+            return
+
+        await _setup(app, new_session)
+
+    async def on_connect():
+        print("connected", config.realm)
+
+    async def on_disconnect():
+        print("disconnected", config.realm)
+        await wait_and_connect()
+
+    session = await client.connect(config.url, config.realm, on_connect, on_disconnect)
+    await _setup(app, session)
+
+    if app.schema_procedure is not None and app.schema_procedure != "":
+        docs = []
+
+        for uri, func in app.procedures.items():
+            docs.append(collect_docs(uri, func, "procedure"))
+
+        for uri, func in app.topics.items():
+            docs.append(collect_docs(uri, func, "topic"))
+
+        async def get_schema(_: Invocation) -> Result:
+            return Result(args=docs)
+
+        options = RegisterOptions(invoke=InvokeOptions.ROUNDROBIN)
+        await session.register(app.schema_procedure, get_schema, options=options)
+        print(f"serving schema at procedure {app.schema_procedure}")
+
+
+@contextlib.asynccontextmanager
+async def resolve_dependencies(meta: ProcedureMetadata) -> AsyncGenerator:
+    result = {}
+
+    for key, value in meta.async_dependencies.items():
+        result[key] = await value()
+
+    async with contextlib.AsyncExitStack() as stack:
+        for name, dependency in meta.async_ctx_dependencies.items():
+            result[name] = await stack.enter_async_context(dependency())
+
+        yield result
+
+
+async def register_async(session: AsyncSession, uri: str, func: callable):
+    if not inspect.iscoroutinefunction(func):
+        raise RuntimeError(f"function {func.__name__} for procedure '{uri}' must be a coroutine")
+
+    meta = _validate_procedure_function(func, uri)
+
+    async def _handle_invocation(invocation: Invocation) -> Result:
+        ensure_caller_allowed(invocation.details, meta.allowed_roles)
+        validate_invocation_parameters(invocation, meta)
+        details = assemble_call_details(uri, meta, invocation)
+
+        if meta.dynamic_model:
+            kwargs = _sanitize_incoming_data(invocation.args, invocation.kwargs, meta.request_args)
+            handle_model_validation(meta.request_model, **kwargs)
+
+            async with resolve_dependencies(meta) as deps:
+                result = await func(**kwargs, **deps, **details)
+
+            return _handle_result(result, meta.response_model, meta.response_args)
+        elif meta.request_model is not None:
+            kwargs = _sanitize_incoming_data(invocation.args, invocation.kwargs, meta.request_args)
+            model = handle_model_validation(meta.request_model, **kwargs, **details)
+            input_data = {meta.positional_field_name: model}
+
+            async with resolve_dependencies(meta) as deps:
+                result = await func(**input_data, **deps, **details)
+
+            return _handle_result(result, meta.response_model, meta.response_args)
+        elif meta.no_args:
+            async with resolve_dependencies(meta) as deps:
+                result = await func(**deps, **details)
+
+            return _handle_result(result, meta.response_model, meta.response_args)
+        else:
+            async with resolve_dependencies(meta) as deps:
+                input_data = {meta.positional_field_name: invocation}
+                result = await func(**input_data, **deps, **details)
+
+            return _handle_result(result, meta.response_model, meta.response_args)
+
+    await session.register(uri, _handle_invocation, options=meta.register_options)
+    print(f"Registered procedure {uri}")
+
+
+async def subscribe_async(session: AsyncSession, topic: str, func: callable):
+    if not inspect.iscoroutinefunction(func):
+        raise RuntimeError(f"function {func.__name__} for topic '{topic}' must be a coroutine")
+
+    meta = _validate_topic_function(func, topic)
+
+    async def _handle_event(event: Event) -> None:
+        details = assemble_event_details(topic, meta, event)
+        validate_event_parameters(event, meta)
+
+        if meta.dynamic_model:
+            kwargs = _sanitize_incoming_data(event.args, event.kwargs, meta.request_args)
+            handle_model_validation(meta.request_model, **kwargs)
+
+            async with resolve_dependencies(meta) as deps:
+                await func(**kwargs, **deps, **details)
+
+        elif meta.request_model is not None:
+            kwargs = _sanitize_incoming_data(event.args, event.kwargs, meta.request_args)
+            model = handle_model_validation(meta.request_model, **kwargs)
+
+            async with resolve_dependencies(meta) as deps:
+                input_data = {meta.positional_field_name: model}
+                await func(**input_data, **deps, **details)
+
+        elif meta.no_args:
+            async with resolve_dependencies(meta) as deps:
+                await func(**deps, **details)
+        else:
+            async with resolve_dependencies(meta) as deps:
+                input_data = {meta.positional_field_name: event}
+                await func(**input_data, **deps, **details)
+
+    await session.subscribe(topic, _handle_event, options=meta.subscribe_options)
+    print(f"Subscribed topic {topic}")

xconn/_client/cli.py

@@ -0,0 +1,176 @@
+import importlib
+import os
+import sys
+
+import yaml
+
+from xconn import App, run
+from xconn._client import helpers
+from xconn.types import WebsocketConfig
+from xconn._client.sync import connect_sync
+from xconn._client.async_ import connect_async
+from xconn._client.types import ClientConfig, CommandArgs
+
+
+def handle_start(command_args: CommandArgs):
+    if command_args.no_config:
+        helpers.validate_auth_inputs(command_args.private_key, command_args.ticket, command_args.secret)
+        config = ClientConfig(
+            url=command_args.url,
+            realm=command_args.realm,
+            authid=command_args.authid,
+            secret=command_args.secret,
+            ticket=command_args.ticket,
+            private_key=command_args.private_key,
+        )
+        config.websocket_config = WebsocketConfig(
+            command_args.open_timeout, command_args.ping_interval, command_args.ping_timeout
+        )
+
+    else:
+        config_path = os.path.join(command_args.directory, "xapp.yaml")
+        if not os.path.exists(config_path):
+            print("xapp.yaml not found, initialize a client first")
+            exit(1)
+
+        flags = (
+            command_args.url,
+            command_args.realm,
+            command_args.authid,
+            command_args.secret,
+            command_args.ticket,
+        )
+        if any(flag is not None for flag in flags):
+            raise RuntimeError("Use either config file OR the individual flags, not both")
+
+        with open(config_path) as f:
+            config_raw = yaml.safe_load(f)
+
+        config = ClientConfig(**config_raw)
+        helpers.validate_auth_inputs(command_args.private_key, command_args.ticket, command_args.secret)
+
+    config.authmethod = helpers.select_authmethod(config)
+
+    split = command_args.app.split(":")
+    if len(split) != 2:
+        raise RuntimeError("invalid app argument, must be of format: module:instance")
+
+    sys.path.append(command_args.directory)
+    module = importlib.import_module(split[0])
+    app: App = getattr(module, split[1])
+    if not isinstance(app, App):
+        raise RuntimeError(f"app instance is of unknown type {type(app)}")
+
+    if command_args.asyncio:
+        run(connect_async(app, config, start_router=command_args.start_router))
+    else:
+        connect_sync(app, config, start_router=command_args.start_router)
+
+
+def handle_init(
+    url: str,
+    realm: str,
+    authid: str,
+    authmethod: str,
+    secret: str,
+    open_timeout: int,
+    ping_interval: int,
+    ping_timeout: int,
+):
+    if os.path.exists("xapp.yaml"):
+        print("xapp.yaml already exists")
+        exit(1)
+
+    if os.path.exists("xapp.py"):
+        print("xapp.py already exists")
+        exit(1)
+
+    with open("xapp.yaml", "w") as f:
+        f.write(
+            yaml.dump(
+                {
+                    "url": url,
+                    "realm": realm,
+                    "authid": authid,
+                    "authmethod": authmethod,
+                    "secret": secret,
+                    "websocket_config": {
+                        "open_timeout": open_timeout,
+                        "ping_interval": ping_interval,
+                        "ping_timeout": ping_timeout,
+                    },
+                }
+            )
+        )
+
+    with open("sample.py", "w") as f:
+        f.write("""from xconn import App
+
+app = App()
+
+@app.register("io.xconn.hello")
+async def my_procedure(first_name: str, last_name: str, age: int):
+    print(first_name + " " + last_name + " " + str(age))
+    return first_name, last_name, age
+
+
+@app.subscribe("io.xconn.publish")
+async def my_topic():
+    print("received event...")
+""")
+
+    print("XConn App initialized.")
+    print("The config is xapp.yaml and sample app is sample.py. Run below command to start the sample")
+    print("")
+    print("xapp start sample:app --asyncio --start-router")
+
+
+def handle_stop(directory: str):
+    # TODO: when the app starts create a xapp.pid with the pid of the process
+    #  when stop is called just request the OS to kill that PID.
+    print(directory)
+
+
+def add_client_subparser(subparsers):
+    start = subparsers.add_parser("start", help="Start XConn App")
+    start.add_argument("APP", type=str)
+    start.add_argument("--url", type=str)
+    start.add_argument("--realm", type=str)
+    start.add_argument("--directory", type=str, default=".")
+    start.add_argument("--asyncio", action="store_true", default=False)
+    start.add_argument("--start-router", action="store_true", default=False)
+    start.add_argument("--authid", type=str)
+    start.add_argument("--secret", type=str)
+    start.add_argument("--ticket", type=str)
+    start.add_argument("--private-key", type=str)
+    start.add_argument("--no-config", action="store_true", default=False)
+    start.add_argument("--open-timeout", type=int, default=10)
+    start.add_argument("--ping-interval", type=int, default=20)
+    start.add_argument("--ping-timeout", type=int, default=20)
+    start.set_defaults(func=lambda args: handle_start(CommandArgs(**vars(args))))
+
+    stop = subparsers.add_parser("stop", help="Stop a running XConn App")
+    stop.add_argument("--directory", type=str, default=".")
+    stop.set_defaults(func=lambda args: handle_stop(args.directory))
+
+    init = subparsers.add_parser("init", help="Init a new XConn App")
+    init.add_argument("--url", type=str, default="ws://127.0.0.1:8080/ws")
+    init.add_argument("--realm", type=str, default="realm1")
+    init.add_argument("--authid", type=str, default="anonymous")
+    init.add_argument("--authmethod", type=str, default="anonymous")
+    init.add_argument("--secret", type=str, default="")
+    init.add_argument("--open-timeout", type=int, default=10)
+    init.add_argument("--ping-interval", type=int, default=20)
+    init.add_argument("--ping-timeout", type=int, default=20)
+    init.set_defaults(
+        func=lambda args: handle_init(
+            args.url,
+            args.realm,
+            args.authid,
+            args.authmethod,
+            args.secret,
+            args.open_timeout,
+            args.ping_interval,
+            args.ping_timeout,
+        )
+    )