ominfra 0.0.0.dev142__py3-none-any.whl → 0.0.0.dev144__py3-none-any.whl

ominfra/manage/__init__.py

@@ -10,4 +10,14 @@ Jobs:
  - system service manager - systemd / supervisor
  - users
  - firewall
+
+Deploy:
+ - User
+ - Dirs
+ - GlobalNginx
+ - GlobalSupervisor
+ - Repo
+ - Venv
+ - Supervisor
+ - Nginx
 """

ominfra/manage/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == '__main__':
+    from .main import _main  # noqa
+
+    _main()

ominfra/manage/bootstrap.py

@@ -0,0 +1,11 @@
+import dataclasses as dc
+
+from .config import MainConfig
+from .remote.config import RemoteConfig
+
+
+@dc.dataclass(frozen=True)
+class MainBootstrap:
+    main_config: MainConfig = MainConfig()
+
+    remote_config: RemoteConfig = RemoteConfig()

ominfra/manage/bootstrap_.py

@@ -0,0 +1,18 @@
+from omlish.lite.inject import Injector
+from omlish.lite.inject import inj
+from omlish.lite.logs import configure_standard_logging
+
+from .bootstrap import MainBootstrap
+from .inject import bind_main
+
+
+def main_bootstrap(bs: MainBootstrap) -> Injector:
+    if (log_level := bs.main_config.log_level) is not None:
+        configure_standard_logging(log_level)
+
+    injector = inj.create_injector(bind_main(  # noqa
+        main_config=bs.main_config,
+        remote_config=bs.remote_config,
+    ))
+
+    return injector

ominfra/manage/commands/base.py

@@ -1,8 +1,13 @@
 # ruff: noqa: UP006 UP007
 import abc
 import dataclasses as dc
+import logging
+import traceback
 import typing as ta
 
+from omlish.lite.check import check_isinstance
+from omlish.lite.strings import snake_case
+
 
 CommandT = ta.TypeVar('CommandT', bound='Command')
 CommandOutputT = ta.TypeVar('CommandOutputT', bound='Command.Output')
@@ -17,11 +22,138 @@ class Command(abc.ABC, ta.Generic[CommandOutputT]):
     class Output(abc.ABC):  # noqa
         pass
 
+    @ta.final
+    def execute(self, executor: 'CommandExecutor') -> CommandOutputT:
+        return check_isinstance(executor.execute(self), self.Output)  # type: ignore[return-value]
+
 
 ##
 
 
+@dc.dataclass(frozen=True)
+class CommandException:
+    name: str
+    repr: str
+
+    traceback: ta.Optional[str] = None
+
+    exc: ta.Optional[ta.Any] = None  # Exception
+
+    cmd: ta.Optional[Command] = None
+
+    @classmethod
+    def of(
+            cls,
+            exc: Exception,
+            *,
+            omit_exc_object: bool = False,
+
+            cmd: ta.Optional[Command] = None,
+    ) -> 'CommandException':
+        return CommandException(
+            name=type(exc).__qualname__,
+            repr=repr(exc),
+
+            traceback=(
+                ''.join(traceback.format_tb(exc.__traceback__))
+                if getattr(exc, '__traceback__', None) is not None else None
+            ),
+
+            exc=None if omit_exc_object else exc,
+
+            cmd=cmd,
+        )
+
+
+class CommandOutputOrException(abc.ABC, ta.Generic[CommandOutputT]):
+    @property
+    @abc.abstractmethod
+    def output(self) -> ta.Optional[CommandOutputT]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def exception(self) -> ta.Optional[CommandException]:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class CommandOutputOrExceptionData(CommandOutputOrException):
+    output: ta.Optional[Command.Output] = None
+    exception: ta.Optional[CommandException] = None
+
+
 class CommandExecutor(abc.ABC, ta.Generic[CommandT, CommandOutputT]):
     @abc.abstractmethod
-    def execute(self, i: CommandT) -> CommandOutputT:
+    def execute(self, cmd: CommandT) -> CommandOutputT:
         raise NotImplementedError
+
+    def try_execute(
+            self,
+            cmd: CommandT,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+            omit_exc_object: bool = False,
+    ) -> CommandOutputOrException[CommandOutputT]:
+        try:
+            o = self.execute(cmd)
+
+        except Exception as e:  # noqa
+            if log is not None:
+                log.exception('Exception executing command: %r', type(cmd))
+
+            return CommandOutputOrExceptionData(exception=CommandException.of(
+                e,
+                omit_exc_object=omit_exc_object,
+                cmd=cmd,
+            ))
+
+        else:
+            return CommandOutputOrExceptionData(output=o)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CommandRegistration:
+    command_cls: ta.Type[Command]
+
+    name: ta.Optional[str] = None
+
+    @property
+    def name_or_default(self) -> str:
+        if not (cls_name := self.command_cls.__name__).endswith('Command'):
+            raise NameError(cls_name)
+        return snake_case(cls_name[:-len('Command')])
+
+
+CommandRegistrations = ta.NewType('CommandRegistrations', ta.Sequence[CommandRegistration])
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class CommandExecutorRegistration:
+    command_cls: ta.Type[Command]
+    executor_cls: ta.Type[CommandExecutor]
+
+
+CommandExecutorRegistrations = ta.NewType('CommandExecutorRegistrations', ta.Sequence[CommandExecutorRegistration])
+
+
+##
+
+
+CommandNameMap = ta.NewType('CommandNameMap', ta.Mapping[str, ta.Type[Command]])
+
+
+def build_command_name_map(crs: CommandRegistrations) -> CommandNameMap:
+    dct: ta.Dict[str, ta.Type[Command]] = {}
+    cr: CommandRegistration
+    for cr in crs:
+        if (name := cr.name_or_default) in dct:
+            raise NameError(name)
+        dct[name] = cr.command_cls
+    return CommandNameMap(dct)

ominfra/manage/commands/execution.py

@@ -0,0 +1,23 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from .base import Command
+from .base import CommandExecutor
+
+
+CommandExecutorMap = ta.NewType('CommandExecutorMap', ta.Mapping[ta.Type[Command], CommandExecutor])
+
+
+class CommandExecutionService(CommandExecutor):
+    def __init__(
+            self,
+            *,
+            command_executors: CommandExecutorMap,
+    ) -> None:
+        super().__init__()
+
+        self._command_executors = command_executors
+
+    def execute(self, cmd: Command) -> Command.Output:
+        ce: CommandExecutor = self._command_executors[type(cmd)]
+        return ce.execute(cmd)

ominfra/manage/commands/inject.py

@@ -0,0 +1,122 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import functools
+import typing as ta
+
+from omlish.lite.inject import Injector
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+from ..config import MainConfig
+from ..marshal import ObjMarshalerInstaller
+from .base import Command
+from .base import CommandExecutor
+from .base import CommandExecutorRegistration
+from .base import CommandExecutorRegistrations
+from .base import CommandNameMap
+from .base import CommandRegistration
+from .base import CommandRegistrations
+from .base import build_command_name_map
+from .execution import CommandExecutionService
+from .execution import CommandExecutorMap
+from .marshal import install_command_marshaling
+from .subprocess import SubprocessCommand
+from .subprocess import SubprocessCommandExecutor
+
+
+##
+
+
+def bind_command(
+        command_cls: ta.Type[Command],
+        executor_cls: ta.Optional[ta.Type[CommandExecutor]],
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(CommandRegistration(command_cls), array=True),
+    ]
+
+    if executor_cls is not None:
+        lst.extend([
+            inj.bind(executor_cls, singleton=True),
+            inj.bind(CommandExecutorRegistration(command_cls, executor_cls), array=True),
+        ])
+
+    return inj.as_bindings(*lst)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class _FactoryCommandExecutor(CommandExecutor):
+    factory: ta.Callable[[], CommandExecutor]
+
+    def execute(self, i: Command) -> Command.Output:
+        return self.factory().execute(i)
+
+
+##
+
+
+def bind_commands(
+        *,
+        main_config: MainConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind_array(CommandRegistration),
+        inj.bind_array_type(CommandRegistration, CommandRegistrations),
+
+        inj.bind_array(CommandExecutorRegistration),
+        inj.bind_array_type(CommandExecutorRegistration, CommandExecutorRegistrations),
+
+        inj.bind(build_command_name_map, singleton=True),
+    ]
+
+    #
+
+    def provide_obj_marshaler_installer(cmds: CommandNameMap) -> ObjMarshalerInstaller:
+        return ObjMarshalerInstaller(functools.partial(install_command_marshaling, cmds))
+
+    lst.append(inj.bind(provide_obj_marshaler_installer, array=True))
+
+    #
+
+    def provide_command_executor_map(
+            injector: Injector,
+            crs: CommandExecutorRegistrations,
+    ) -> CommandExecutorMap:
+        dct: ta.Dict[ta.Type[Command], CommandExecutor] = {}
+
+        cr: CommandExecutorRegistration
+        for cr in crs:
+            if cr.command_cls in dct:
+                raise KeyError(cr.command_cls)
+
+            factory = functools.partial(injector.provide, cr.executor_cls)
+            if main_config.debug:
+                ce = factory()
+            else:
+                ce = _FactoryCommandExecutor(factory)
+
+            dct[cr.command_cls] = ce
+
+        return CommandExecutorMap(dct)
+
+    lst.extend([
+        inj.bind(provide_command_executor_map, singleton=True),
+
+        inj.bind(CommandExecutionService, singleton=True, eager=main_config.debug),
+        inj.bind(CommandExecutor, to_key=CommandExecutionService),
+    ])
+
+    #
+
+    for command_cls, executor_cls in [
+        (SubprocessCommand, SubprocessCommandExecutor),
+    ]:
+        lst.append(bind_command(command_cls, executor_cls))
+
+    #
+
+    return inj.as_bindings(*lst)

ominfra/manage/commands/marshal.py

@@ -0,0 +1,26 @@
+from omlish.lite.marshal import ObjMarshalerManager
+from omlish.lite.marshal import PolymorphicObjMarshaler
+
+from .base import Command
+from .base import CommandNameMap
+
+
+def install_command_marshaling(
+        cmds: CommandNameMap,
+        msh: ObjMarshalerManager,
+) -> None:
+    for fn in [
+        lambda c: c,
+        lambda c: c.Output,
+    ]:
+        msh.register_opj_marshaler(
+            fn(Command),
+            PolymorphicObjMarshaler.of([
+                PolymorphicObjMarshaler.Impl(
+                    fn(cmd),
+                    name,
+                    msh.get_obj_marshaler(fn(cmd)),
+                )
+                for name, cmd in cmds.items()
+            ]),
+        )

ominfra/manage/config.py

@@ -0,0 +1,10 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class MainConfig:
+    log_level: ta.Optional[str] = 'INFO'
+
+    debug: bool = False

ominfra/manage/deploy/command.py

@@ -0,0 +1,23 @@
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+
+from ..commands.base import Command
+from ..commands.base import CommandExecutor
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class DeployCommand(Command['DeployCommand.Output']):
+    @dc.dataclass(frozen=True)
+    class Output(Command.Output):
+        pass
+
+
+##
+
+
+class DeployCommandExecutor(CommandExecutor[DeployCommand, DeployCommand.Output]):
+    def execute(self, cmd: DeployCommand) -> DeployCommand.Output:
+        return DeployCommand.Output()

ominfra/manage/deploy/inject.py

@@ -0,0 +1,19 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+
+from ..commands.inject import bind_command
+from .command import DeployCommand
+from .command import DeployCommandExecutor
+
+
+def bind_deploy(
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        bind_command(DeployCommand, DeployCommandExecutor),
+    ]
+
+    return inj.as_bindings(*lst)

ominfra/manage/inject.py

@@ -0,0 +1,58 @@
+# ruff: noqa: UP006 UP007
+import typing as ta
+
+from omlish.lite.inject import InjectorBindingOrBindings
+from omlish.lite.inject import InjectorBindings
+from omlish.lite.inject import inj
+from omlish.lite.marshal import ObjMarshalerManager
+
+from .commands.inject import bind_commands
+from .config import MainConfig
+from .deploy.inject import bind_deploy
+from .marshal import ObjMarshalerInstaller
+from .marshal import ObjMarshalerInstallers
+from .remote.config import RemoteConfig
+from .remote.inject import bind_remote
+
+
+##
+
+
+def bind_main(
+        *,
+        main_config: MainConfig,
+        remote_config: RemoteConfig,
+) -> InjectorBindings:
+    lst: ta.List[InjectorBindingOrBindings] = [
+        inj.bind(main_config),
+
+        bind_commands(
+            main_config=main_config,
+        ),
+
+        bind_remote(
+            remote_config=remote_config,
+        ),
+
+        bind_deploy(),
+    ]
+
+    #
+
+    def build_obj_marshaler_manager(insts: ObjMarshalerInstallers) -> ObjMarshalerManager:
+        msh = ObjMarshalerManager()
+        inst: ObjMarshalerInstaller
+        for inst in insts:
+            inst.fn(msh)
+        return msh
+
+    lst.extend([
+        inj.bind(build_obj_marshaler_manager, singleton=True),
+
+        inj.bind_array(ObjMarshalerInstaller),
+        inj.bind_array_type(ObjMarshalerInstaller, ObjMarshalerInstallers),
+    ])
+
+    #
+
+    return inj.as_bindings(*lst)

ominfra/manage/main.py

@@ -5,72 +5,24 @@
 manage.py -s 'docker run -i python:3.12'
 manage.py -s 'ssh -i /foo/bar.pem foo@bar.baz' -q --python=python3.8
 """
-from omlish.lite.marshal import OBJ_MARSHALER_MANAGER
+import contextlib
+import typing as ta
+
+from omlish.lite.logs import log  # noqa
 from omlish.lite.marshal import ObjMarshalerManager
-from omlish.lite.marshal import PolymorphicObjMarshaler
+from omlish.lite.marshal import ObjMarshalOptions
+from omlish.lite.pycharm import PycharmRemoteDebug
 
-from ..pyremote import PyremoteBootstrapDriver
-from ..pyremote import PyremoteBootstrapOptions
-from ..pyremote import pyremote_bootstrap_finalize
-from ..pyremote import pyremote_build_bootstrap_cmd
+from .bootstrap import MainBootstrap
+from .bootstrap_ import main_bootstrap
 from .commands.base import Command
+from .commands.base import CommandExecutor
 from .commands.subprocess import SubprocessCommand
-from .commands.subprocess import SubprocessCommandExecutor
-from .payload import get_payload_src
-from .protocol import Channel
-from .spawning import PySpawner
-
-
-##
-
-
-_COMMAND_TYPES = {
-    'subprocess': SubprocessCommand,
-}
-
-
-##
-
-
-def register_command_marshaling(msh: ObjMarshalerManager) -> None:
-    for fn in [
-        lambda c: c,
-        lambda c: c.Output,
-    ]:
-        msh.register_opj_marshaler(
-            fn(Command),
-            PolymorphicObjMarshaler.of([
-                PolymorphicObjMarshaler.Impl(
-                    fn(cty),
-                    k,
-                    msh.get_obj_marshaler(fn(cty)),
-                )
-                for k, cty in _COMMAND_TYPES.items()
-            ]),
-        )
-
-
-register_command_marshaling(OBJ_MARSHALER_MANAGER)
-
-
-##
-
-
-def _remote_main() -> None:
-    rt = pyremote_bootstrap_finalize()  # noqa
-    chan = Channel(rt.input, rt.output)
-
-    while True:
-        i = chan.recv_obj(Command)
-        if i is None:
-            break
-
-        if isinstance(i, SubprocessCommand):
-            o = SubprocessCommandExecutor().execute(i)  # noqa
-        else:
-            raise TypeError(i)
-
-        chan.send_obj(o, Command.Output)
+from .config import MainConfig
+from .deploy.command import DeployCommand
+from .remote.config import RemoteConfig
+from .remote.execution import RemoteExecution
+from .remote.spawning import RemoteSpawning
 
 
 ##
@@ -87,50 +39,72 @@ def _main() -> None:
     parser.add_argument('-q', '--shell-quote', action='store_true')
     parser.add_argument('--python', default='python3')
 
+    parser.add_argument('--pycharm-debug-port', type=int)
+    parser.add_argument('--pycharm-debug-host')
+    parser.add_argument('--pycharm-debug-version')
+
     parser.add_argument('--debug', action='store_true')
 
+    parser.add_argument('--local', action='store_true')
+
+    parser.add_argument('command', nargs='+')
+
     args = parser.parse_args()
 
     #
 
-    payload_src = get_payload_src(file=args._payload_file)  # noqa
+    bs = MainBootstrap(
+        main_config=MainConfig(
+            log_level='DEBUG' if args.debug else 'INFO',
 
-    remote_src = '\n\n'.join([
-        '__name__ = "__remote__"',
-        payload_src,
-        '_remote_main()',
-    ])
+            debug=bool(args.debug),
+        ),
 
-    #
+        remote_config=RemoteConfig(
+            payload_file=args._payload_file,  # noqa
 
-    spawner = PySpawner(
-        pyremote_build_bootstrap_cmd(__package__ or 'manage'),
-        shell=args.shell,
-        shell_quote=args.shell_quote,
-        python=args.python,
+            pycharm_remote_debug=PycharmRemoteDebug(
+                port=args.pycharm_debug_port,
+                host=args.pycharm_debug_host,
+                install_version=args.pycharm_debug_version,
+            ) if args.pycharm_debug_port is not None else None,
+        ),
     )
 
-    with spawner.spawn() as proc:
-        res = PyremoteBootstrapDriver(  # noqa
-            remote_src,
-            PyremoteBootstrapOptions(
-                debug=args.debug,
-            ),
-        ).run(proc.stdout, proc.stdin)
+    injector = main_bootstrap(
+        bs,
+    )
 
-        chan = Channel(proc.stdout, proc.stdin)
+    #
+
+    cmds: ta.List[Command] = []
+    for c in args.command:
+        if c == 'deploy':
+            cmds.append(DeployCommand())
+        else:
+            cmds.append(SubprocessCommand([c]))
+
+    #
+
+    with contextlib.ExitStack() as es:
+        ce: CommandExecutor
 
-        #
+        if args.local:
+            ce = injector[CommandExecutor]
+
+        else:
+            tgt = RemoteSpawning.Target(
+                shell=args.shell,
+                shell_quote=args.shell_quote,
+                python=args.python,
+            )
 
-        for ci in [
-            SubprocessCommand(['python3', '-'], input=b'print(1)\n'),
-            SubprocessCommand(['uname']),
-        ]:
-            chan.send_obj(ci, Command)
+            ce = es.enter_context(injector[RemoteExecution].connect(tgt, bs))  # noqa
 
-            o = chan.recv_obj(Command.Output)
+        for cmd in cmds:
+            r = ce.try_execute(cmd)
 
-            print(o)
+            print(injector[ObjMarshalerManager].marshal_obj(r, opts=ObjMarshalOptions(raw_bytes=True)))
 
 
 if __name__ == '__main__':

ominfra/manage/marshal.py

@@ -0,0 +1,12 @@
+import dataclasses as dc
+import typing as ta
+
+from omlish.lite.marshal import ObjMarshalerManager
+
+
+@dc.dataclass(frozen=True)
+class ObjMarshalerInstaller:
+    fn: ta.Callable[[ObjMarshalerManager], None]
+
+
+ObjMarshalerInstallers = ta.NewType('ObjMarshalerInstallers', ta.Sequence[ObjMarshalerInstaller])