ominfra 0.0.0.dev141__py3-none-any.whl → 0.0.0.dev143__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/commands/subprocess.py

@@ -5,6 +5,8 @@ import subprocess
 import time
 import typing as ta
 
+from omlish.lite.subprocesses import SUBPROCESS_CHANNEL_OPTION_VALUES
+from omlish.lite.subprocesses import SubprocessChannelOption
 from omlish.lite.subprocesses import subprocess_maybe_shell_wrap_exec
 
 from .base import Command
@@ -16,21 +18,21 @@ from .base import CommandExecutor
 
 @dc.dataclass(frozen=True)
 class SubprocessCommand(Command['SubprocessCommand.Output']):
-    args: ta.Sequence[str]
+    cmd: ta.Sequence[str]
 
     shell: bool = False
     cwd: ta.Optional[str] = None
     env: ta.Optional[ta.Mapping[str, str]] = None
 
-    capture_stdout: bool = False
-    capture_stderr: bool = False
+    stdout: str = 'pipe'  # SubprocessChannelOption
+    stderr: str = 'pipe'  # SubprocessChannelOption
 
     input: ta.Optional[bytes] = None
     timeout: ta.Optional[float] = None
 
     def __post_init__(self) -> None:
-        if isinstance(self.args, str):
-            raise TypeError(self.args)
+        if isinstance(self.cmd, str):
+            raise TypeError(self.cmd)
 
     @dc.dataclass(frozen=True)
     class Output(Command.Output):
@@ -48,24 +50,23 @@ class SubprocessCommand(Command['SubprocessCommand.Output']):
 
 class SubprocessCommandExecutor(CommandExecutor[SubprocessCommand, SubprocessCommand.Output]):
     def execute(self, inp: SubprocessCommand) -> SubprocessCommand.Output:
-        proc = subprocess.Popen(
-            subprocess_maybe_shell_wrap_exec(*inp.args),
+        with subprocess.Popen(
+            subprocess_maybe_shell_wrap_exec(*inp.cmd),
 
             shell=inp.shell,
             cwd=inp.cwd,
             env={**os.environ, **(inp.env or {})},
 
             stdin=subprocess.PIPE if inp.input is not None else None,
-            stdout=subprocess.PIPE if inp.capture_stdout else None,
-            stderr=subprocess.PIPE if inp.capture_stderr else None,
-        )
-
-        start_time = time.time()
-        stdout, stderr = proc.communicate(
-            input=inp.input,
-            timeout=inp.timeout,
-        )
-        end_time = time.time()
+            stdout=SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, inp.stdout)],
+            stderr=SUBPROCESS_CHANNEL_OPTION_VALUES[ta.cast(SubprocessChannelOption, inp.stderr)],
+        ) as proc:
+            start_time = time.time()
+            stdout, stderr = proc.communicate(
+                input=inp.input,
+                timeout=inp.timeout,
+            )
+            end_time = time.time()
 
         return SubprocessCommand.Output(
             rc=proc.returncode,

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/inject.py

@@ -0,0 +1,55 @@
+# 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 .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,
+        ),
+    ]
+
+    #
+
+    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)