def includeme(app: App): app.include("discovery") # TODO: spawn, when using # TODO: spawn, when dry_run=False only def _register(): from discovery import get_discovery port = None if app.registry.dry_run: logger.info("dry run, %s skipped", NAME) get_discovery().register("gofmtrpc", url=f"http://127.0.0.1:{port}") return from egoist.internal.netutil import find_free_port from util import spawn_with_connection port = find_free_port() get_discovery().register("gofmtrpc", url=f"http://127.0.0.1:{port}") argv = ["gofmtrpc", "-addr", f":{port}"] p, _ = spawn_with_connection(argv, sentinel_option="-sentinel") import atexit def _shutdown(): logger.info("terminate gofmtrpc") with p: p.terminate() atexit.register(_shutdown) app.action(NAME, _register)
def includeme(app: App): app.include("discovery") # TODO: only spawn, when using def _register(): import shutil from egoist.internal.netutil import find_free_port from discovery import get_discovery import util sentinel = util.create_sentinel_file() port = find_free_port() get_discovery().register("gofmtrpc", url=f"http://127.0.0.1:{port}") assert shutil.which("gofmtrpc") argv = [ "gofmtrpc", "-addr", f":{port}", "-sentinel", sentinel, ] p = util.ConnectedProcess().spawn(argv, sentinel=sentinel) import atexit def _shutdown(): logger.info("terminate gofmtrpc") with p: p.terminate() atexit.register(_shutdown) app.action(NAME, _register)
def includeme(app: App) -> None: app.include(".tracker") actual: FSFactory = create_fs app.register_factory(NAME, actual) for_dry_run: FSFactory = create_dummy_fs app.register_dryurn_factory(NAME, for_dry_run)
def setup_server(app: App) -> None: from egoist.ext.serverprocess.lazyparams import find_free_port, create_sentinel_file app.include("egoist.ext.serverprocess") # for add_server_process app.add_server_process( "uvicorn server:app --port {port}", params=dict(port=find_free_port), name="api-server", env={"SENTINEL": create_sentinel_file}, )
def includeme(app: App) -> None: app.include("directives.define_server_process") from rpcutil import find_free_port, create_sentinel_file app.define_server_process( "gofmtrpc -addr :{port} -sentinel {sentinel}", params=dict(port=find_free_port, sentinel=create_sentinel_file), name="gofmtrpc", )
def includeme(app: App) -> None: from egoist.experimental.serverprocess.lazyparams import find_free_port, create_sentinel_file app.include("egoist.experimental.serverprocess") # for add_server_process app.add_server_process( "gofmtrpc -addr :{port} -sentinel {sentinel}", params=dict(port=find_free_port, sentinel=create_sentinel_file), name=NAME, )
def define_server_process(app: App): def _define( app: App, fmt: str, *, name: str, urlfmt: str = "http://{host}:{port}", host: str = "127.0.0.1", port: t.Optional[int] = None, params: t.Optional[t.Dict[str, t.Callable[[], object]]] = None, ): def _register(): nonlocal host nonlocal port import shlex import atexit from discovery import get_discovery from rpcutil import find_free_port kwargs = {k: fn(app) for k, fn in (params or {}).items()} if port is None: port = kwargs.get("port") or find_free_port() if "host" in kwargs: host = kwargs.get["host"] argv = shlex.split(fmt.format(**kwargs)) url = urlfmt.format(host=host, port=port) get_discovery().register(name, url=url) if app.registry.dry_run: logger.info("dry run, %s skipped", name) return from spawn import spawn_with_connection p, _ = spawn_with_connection(argv) def _shutdown(): # xxx: logger.info("terminate %s", name) with p: p.terminate() atexit.register(_shutdown) app.action(("define_server_process", name), _register) app.include("discovery") app.add_directive("define_server_process", _define)
def includeme(app: App): app.include("discovery") # TODO: only spawn, when using def _register(): import sys import pathlib from egoist.internal.netutil import find_free_port from discovery import get_discovery import util sentinel = util.create_sentinel_file() server_py = pathlib.Path(__file__).absolute().with_name("server.py") port = find_free_port() get_discovery().register("HELLO", url=f"http://127.0.0.1:{port}") argv = [ sys.executable, server_py, "--port", str(port), "--host", "127.0.0.1", "--sentinel", sentinel, ] p = util.ConnectedProcess().spawn(argv, sentinel=sentinel) import atexit def _shutdown(): logger.info("terminate HELLO") with p: p.terminate() atexit.register(_shutdown) app.action(NAME, _register)
from egoist.app import App, SettingsDict, parse_args settings: SettingsDict = {"rootdir": "output", "here": __file__} app = App(settings) app.include("egoist.directives.define_file") @app.define_file("egoist.generators.filekit:walk", suffix=".txt") def hello() -> None: from egoist.generators.filekit import runtime with runtime.create_file() as wf: print("hello world", file=wf) if __name__ == "__main__": for argv in parse_args(sep="-"): app.run(argv)
def setup_server(app: App) -> None: from egoist.ext.serverprocess.lazyparams import find_free_port, create_sentinel_file app.include("egoist.ext.serverprocess") # for add_server_process
from __future__ import annotations import typing as t from egoist.app import App app = App(settings={"here": __file__, "rootdir": ""}) app.include("egoist.directives.define_struct_set") @app.define_struct_set("egoist.generators.structkit:walk") # type: ignore def models__models() -> None: from egoist.generators.structkit import runtime, structkit import objects @runtime.set_metadata_handler def metadata_handler(cls: t.Type[t.Any], *, name: str, info: t.Any, metadata: runtime.Metadata) -> None: """with form""" metadata["tags"] = { "json": [name.rstrip("_")], "form": [name.rstrip("_")] } with runtime.generate(structkit, classes=[objects.Person]) as m: m.package("models") if __name__ == "__main__": app.run()
def includeme(app: App) -> None: app.include("egoist.components.tracker") app.include("egoist.directives.add_subcommand") app.include("egoist.commands.generate") app.add_subcommand(setup, fn=makegen)
from egoist.app import App, SettingsDict settings: SettingsDict = {"root": "cmd/", "here": __file__} app = App(settings) app.include("egoist.directives.define_cli") @app.define_cli("egoist.generate.clikit:walk") def hello(*, name: str) -> None: """hello message""" from egoist.generate.clikit import runtime, clikit with runtime.generate(clikit): runtime.printf("hello %s\n", name) if __name__ == "__main__": app.run()
@directive(name="define_foo", requires=["egoist.commands.describe"]) def define_foo(app: App, fn: AnyFunction, name: str) -> AnyFunction: """*** define foo ***""" print(app, fn, "foo", name) def _register(): print("!") app.registry.generators[name].append(fn) app.action(fn.__name__, _register) return fn if __name__ == "__main__": app = App() app.include("__main__.define_foo") @app.define_foo("xxx") def yyy(): print("yyy") @app.define_foo("xxx") def zzz(): print("zzz") print("s") app.commit() yyy() zzz() print("e")
def _define( app: App, fmt: str, *, name: str, urlfmt: str = "http://{host}:{port}", host: str = "127.0.0.1", port: t.Optional[t.Union[int, str]] = None, params: t.Optional[t.Dict[str, LazyParam]] = None, env: t.Optional[t.Dict[str, LazyParam]] = None, cwd: t.Union[str, pathlib.Path, None] = None, nowait: bool = False, ) -> None: app.include("egoist.experimental.serverprocess.components.discovery") app.include("egoist.experimental.serverprocess.components.httpclient") def _register() -> None: nonlocal host nonlocal port import shlex import atexit from .components.discovery import get_discovery from .lazyparams import find_free_port, create_sentinel_file if app.registry.dry_run: kwargs: t.Dict[str, t.Any] = { k: "xxx" for k in (params or {}).keys() } environ = {k: "xxx" for k in (env or {}).keys()} port = "xxx" sentinel = "xxx" else: kwargs = {k: fn(app) for k, fn in (params or {}).items()} environ = {k: fn(app) for k, fn in (env or {}).items()} if port is None: port = (kwargs.get("port") or environ.get("port") or environ.get("PORT") or find_free_port(app)) elif "port" not in kwargs: kwargs["port"] = port if "host" in kwargs: host = kwargs["host"] elif "host" not in kwargs: kwargs["host"] = host sentinel = ( # xxx kwargs.get("sentinel") or environ.get("SENTINEL") or ("" if nowait else create_sentinel_file(app))) argv = shlex.split(fmt.format(**kwargs)) url = urlfmt.format(host=host, port=port) get_discovery().register(name, url=url) if app.registry.dry_run: logger.info("dry run, skip starting server process, %s", name) return from .spawn import spawn_with_connection p, _ = spawn_with_connection(argv, sentinel=sentinel, environ=environ, cwd=cwd, check=not nowait) def _shutdown() -> None: # xxx: logger.info("terminate %s", name) with p: p.terminate() atexit.register(_shutdown) app.action(("add_server_process", name), _register)
def includeme(app: App) -> None: app.include("egoist.directives.add_subcommand") app.include(".generate") app.add_subcommand(setup, fn=scan)
def includeme(app: App) -> None: app.include("egoist.components.fs")
def includeme(app: App) -> None: app.include("egoist.directives.add_subcommand") app.add_subcommand(setup, fn=hello)
from egoist.app import App, SettingsDict, parse_args settings: SettingsDict = {"rootdir": "cmd/", "here": __file__} app = App(settings) app.include("egoist.commands.generate") app.include("egoist.directives.define_cli") @app.define_cli("egoist.generators.clikit:walk") def hello(*, name: str) -> None: """hello message""" from egoist.generators.clikit import runtime, clikit with runtime.generate(clikit): runtime.printf("hello %s\n", name) if __name__ == "__main__": for argv in parse_args(sep="-"): app.run(argv)
def includeme(app: App) -> None: app.include("./directives:add_server_process") # for add_server_process()