infrable 0.0.1__py3-none-any.whl

infrable/__init__.py

@@ -0,0 +1,9 @@
+__version__ = "0.0.1"
+
+from infrable.distro.linux import LinuxLatestHost
+from infrable.distro.ubuntu import UbuntuLatestHost
+from infrable.host import Host
+from infrable.meta import Meta
+from infrable.readfile import readfile
+from infrable.service import Service
+from infrable.switch import Switch

infrable/cli/files.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+
+import typer
+
+from infrable import files
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command(help=files.affected_hosts.__doc__)
+def affected_hosts(only: list[str] = typer.Option(None)):
+    for host in files.affected_hosts(only=only):
+        print(host)
+
+
+@app.command(help=files.deploy.__doc__)
+def deploy(
+    path: Path = typer.Argument(None),
+    only: list[str] = typer.Option(None),
+    yes: bool = False,
+):
+    files.deploy(path, only=only, yes=yes)
+
+
+@app.command(help=files.recover.__doc__)
+def recover(path: Path = typer.Argument(None)):
+    files.recover(path)
+
+
+@app.command(help=files.gen.__doc__)
+def gen(
+    path: Path = typer.Argument(None),
+    only: list[str] = typer.Option(None),
+):
+    files.gen(path, only=only)
+
+
+app.command()(files.backup)
+app.command()(files.pull)
+app.command()(files.diff)
+app.command()(files.push)
+
+
+@app.command(help=files.revert.__doc__)
+def revert(path: Path = typer.Argument(None)):
+    files.revert(path)

infrable/cli/main.py

@@ -0,0 +1,69 @@
+import sys
+
+import typer
+
+from infrable import errors, infra, init
+from infrable.cli import files, remote, switch
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command()
+def hosts(format: str | None = None, repr: bool = False):
+    """List all hosts in the infrastructure."""
+
+    for name, host in infra.hosts.items():
+        if format:
+            print(host.format(name, format=format))
+        elif repr:
+            print(f"{name} = {host.__repr__()}")
+        else:
+            print(f"{name} = {host}")
+
+
+@app.command()
+def services(format: str | None = None, repr: bool = False):
+    """List all services in the infrastructure."""
+
+    for name, service in infra.services.items():
+        if format:
+            print(service.format(name, format=format))
+        elif repr:
+            print(f"{name} = {service.__repr__()}")
+        else:
+            print(f"{name} = {service}")
+
+
+@app.command()
+def switches(format: str | None = None, repr: bool = False):
+    """List all switches in the infrastructure."""
+
+    for name, switch in infra.switches.items():
+        if format:
+            print(switch.format(name, format=format))
+        elif repr:
+            print(f"{name} = {switch.__repr__()}")
+        else:
+            print(f"{name} = {switch}")
+
+
+@app.command(name="init")
+def init_():
+    """Bootstrap a dummy project."""
+    init.init()
+
+
+app.add_typer(files.app, name="files", help="Manage files.")
+app.add_typer(switch.app, name="switch", help="Manage switches.")
+app.add_typer(remote.app, name="remote", help="Execute remote commands.")
+
+for name, ext in infra.typers.items():
+    app.add_typer(ext, name=name.replace("_", "-"))
+
+
+if __name__ == "__main__":
+    try:
+        app()
+    except errors.Error as e:
+        print(e, file=sys.stderr)
+        raise typer.Exit(1) from e

infrable/cli/remote.py

@@ -0,0 +1,86 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Iterable
+
+import typer
+from tqdm import tqdm
+
+from infrable import Host, files, infra
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command(name="-")
+def from_stdin(command: str):
+    """Execute a script on the list of hosts passed via stdin."""
+
+    hosts = []
+    for line in typer.get_text_stream("stdin").readlines():
+        host = line.split(maxsplit=1)[0].split("@", 1)[-1].strip()
+        if not host:
+            continue
+        for host in infra.filtered_hosts(only=[host]):
+            hosts.append(host)
+
+    _execute(hosts, command=command)
+
+
+@app.command()
+def infra_hosts(command: str, only: list[str] = typer.Option(None)):
+    """Execute a script on the hosts listed in the infra."""
+
+    hosts = infra.hosts.values()
+    if only:
+        hosts = infra.filtered_hosts(only=only)
+
+    _execute(hosts, command=command)
+
+
+@app.command()
+def affected_hosts(command: str, only: list[str] = typer.Option(None)):
+    """Execute a script on the affected hosts in the last deployment."""
+
+    hosts = files.affected_hosts()
+
+    if only:
+        only_hosts = set(h.fqdn for h in infra.filtered_hosts(only=only))
+        hosts = (h for h in hosts if h.fqdn in only_hosts)
+
+    _execute(hosts, command=command)
+
+
+for name, group in infra.host_groups.items():
+
+    def groupmain(command: str, only: list[str] = typer.Option(None)):
+        hosts = group
+        if only:
+            only_hosts = set(h.fqdn for h in infra.filtered_hosts(only=only))
+            hosts = (h for h in hosts if h.fqdn in only_hosts)
+
+        _execute(hosts, command=command)
+
+    help = f"Execute a script on {name} hosts."
+    app.command(name=name, help=help)(groupmain)
+
+
+for name, host in infra.hosts.items():
+
+    def hostmaain(command: str):
+        host.remote()(command, _fg=True)
+
+    help = f"Execute a script on {name}."
+    app.command(name=name, help=help)(hostmaain)
+
+
+def _execute(hosts: Iterable[Host], command: str):
+    hosts = {h.ip: h for h in hosts}.values()
+    futures = []
+    with ThreadPoolExecutor(max_workers=4) as pool:
+        for h in hosts:
+            fut = pool.submit(lambda: (h, h.remote()(command, _err_to_out=True)))
+            futures.append(fut)
+        print()
+        for result in tqdm(as_completed(futures), total=len(futures)):
+            host, result = result.result()
+            typer.secho(f"╭ {host}", bold=True)
+            print(result)
+            print()

infrable/cli/switch.py

@@ -0,0 +1,15 @@
+import typer
+from click import Choice
+
+from infrable import infra
+
+app = typer.Typer(no_args_is_help=True)
+
+
+for name, sw in infra.switches.items():
+    help = f"Set the value of the {name} switch."
+
+    def main(value: str = typer.Argument(..., click_type=Choice(list(sw.options)))):
+        sw.set(value)
+
+    app.command(name=name, help=help)(main)

infrable/distro/linux.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass, field
+from shlex import quote as q
+from typing import Optional
+
+from infrable import errors
+from infrable.host import Host
+
+
+@dataclass(unsafe_hash=True, order=True, eq=True)
+class LinuxLatestHost(Host):
+    """A latest version of generic Linux host."""
+
+    authorized_keys: str = ""
+    users: dict[str, dict[str, str]] = field(default_factory=dict)
+
+    def setup(self, as_root: bool = False):
+        self.ensure_admin(as_root=as_root)
+        self.disable_root_login()
+        self.ensure_hostname()
+        self.ensure_users()
+
+    def ensure_hostname(self, fqdn: str | None = None):
+        fqdn = fqdn or self.fqdn
+        if not fqdn:
+            raise errors.FQDNMustNotBeEmptyError()
+        self.remote().sudo.tee("/etc/hostname", _in=fqdn.split(".", 1)[0], _fg=True)
+
+    def ensure_admin(
+        self,
+        username: str | None = None,
+        authorized_keys: str | None = None,
+        as_root: bool = False,
+    ):
+        username = username or self.admin
+        self.ensure_user(username, as_root=as_root)
+        self.ensure_authorized_keys(username, keys=authorized_keys, as_root=as_root)
+        self.ensure_sudoer(username, as_root=as_root)
+
+    def ensure_sudoer(
+        self,
+        username: Optional[str] = None,
+        access: str = "ALL=(ALL) NOPASSWD:ALL",
+        as_root: bool = False,
+    ):
+        conn = self.remote("root") if as_root else self.remote().sudo
+        username = username or self.admin
+        if not conn.ls(q(f"/etc/sudoers.d/{username}"), _ok_code=[0, 2]):
+            conn.tee(
+                q(f"/etc/sudoers.d/{username}"),
+                _in=f"{username} {access}",
+            )
+
+            conn.chmod("0440", q(f"/etc/sudoers.d/{username}"))
+        self.remote(username).sudo.echo("sudo setup successful", _fg=True)
+
+    def ensure_user(
+        self, username: str, shell: str = "/bin/bash", as_root: bool = False
+    ):
+        conn = self.remote("root") if as_root else self.remote().sudo
+        if not conn.id(q(username), _ok_code=[0, 1]):
+            conn.useradd("-m", "-s", q(shell), q(username), _fg=True)
+
+    def ensure_users(self, users: dict[str, dict[str, str]] | None = None):
+        for username, config in (users or self.users).items():
+            self.ensure_user(username, **config, as_root=False)
+
+    def ensure_authorized_keys(
+        self, username: str, keys: str | None, as_root: bool = False
+    ):
+        conn = self.remote("root") if as_root else self.remote().sudo
+        sshdir = f"/home/{username}/.ssh"
+        dest = f"/{sshdir}/authorized_keys"
+        conn.mkdir("-pv", q(sshdir), _fg=True)
+        conn.tee(q(dest), _in=keys or self.authorized_keys)
+        conn.chown("-R", q(f"{username}:{username}"), sshdir, _fg=True)
+        conn.chmod("0600", dest, _fg=True)
+        self.remote(login=username).echo(f"{username}: ssh setup successful", _fg=True)
+
+    def disable_root_login(self):
+        sudo_conn = self.remote().sudo
+        if sudo_conn.grep(
+            q("^PermitRootLogin\\syes"), "/etc/ssh/sshd_config", _ok_code=[0, 1]
+        ):
+            sudo_conn.sed("-i", "/^PermitRootLogin/s/yes/no/", "/etc/ssh/sshd_config")
+            sudo_conn.systemctl.reload.ssh()

infrable/distro/ubuntu.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass, field
+from shlex import quote as q
+
+from infrable.distro.linux import LinuxLatestHost
+
+
+@dataclass(unsafe_hash=True, order=True, eq=True)
+class UbuntuLatestHost(LinuxLatestHost):
+    """A latest version of Ubuntu."""
+
+    packages: list[str] = field(default_factory=list)
+
+    def setup(self, as_root: bool = False):
+        super().setup(as_root=as_root)
+        self.upgrade_packages()
+        self.update_packages()
+        self.ensure_apt_packages()
+
+    def upgrade_packages(self):
+        self.remote().sudo(
+            "apt-get", "-o", "DPkg::Lock::Timeout=60", "upgrade", "-y", _fg=True
+        )
+
+    def update_packages(self):
+        self.remote().sudo(
+            "apt-get", "-o", "DPkg::Lock::Timeout=60", "update", "-y", _fg=True
+        )
+
+    def ensure_apt_packages(self, packages: list[str] | None = None):
+        packages = packages or self.packages
+        if packages:
+            self.remote().sudo(
+                "apt-get", "-o", "DPkg::Lock::Timeout=60", "update", "-y", _fg=True
+            )
+            package_batches = [
+                self.packages[i : i + 10] for i in range(0, len(packages), 10)
+            ]
+            for batch in package_batches:
+                self.remote().sudo(
+                    "apt-get",
+                    "-o",
+                    "DPkg::Lock::Timeout=60",
+                    "install",
+                    "-y",
+                    *[q(pkg) for pkg in batch],
+                    _fg=True,
+                )
+            self.remote().sudo(
+                "apt-get", "-o", "DPkg::Lock::Timeout=60", "autoremove", "-y", _fg=True
+            )
+
+    def disable_root_login(self):
+        sudo_conn = self.remote().sudo
+        if sudo_conn.grep(
+            q("^PermitRootLogin\\syes"), "/etc/ssh/sshd_config", _ok_code=[0, 1]
+        ):
+            sudo_conn.sed("-i", "/^PermitRootLogin/s/yes/no/", "/etc/ssh/sshd_config")
+            sudo_conn.systemctl.reload.ssh()

infrable/errors.py

@@ -0,0 +1,60 @@
+class Error(Exception):
+    pass
+
+
+class FQDNMustNotBeEmptyError(Error, ValueError):
+    def __init__(self):
+        super().__init__(f"Error: FQDN must not be empty")
+
+
+class MissingMetadataError(Error, ValueError):
+    def __init__(self, src):
+        super().__init__(f"missing metadata in template: {src}")
+
+
+class MissingDestinationError(Error, ValueError):
+    def __init__(self, src):
+        super().__init__(f"missing `dest` in template metadata: {src}")
+
+
+class InvalidDestinationError(Error, ValueError):
+    def __init__(self, dest):
+        super().__init__(f"invalid destination: {dest}")
+
+
+class InfraDotPyNotFoundError(Error, ImportError):
+    def __init__(self, modulename):
+        super().__init__(f"{modulename}.py: file not found")
+
+
+class HostOrServiceNotFoundError(Error, KeyError):
+    def __init__(self, name):
+        super().__init__(f"{name}: host or service not found")
+
+
+class SwitchValueError(Error, ValueError):
+    def __init__(self, path, value, options):
+        options = ", ".join(options)
+        super().__init__(
+            f"Invalid value {value} for switch {path}. Options are: {options}"
+        )
+
+
+class SwitchCaseError(Error, ValueError):
+    def __init__(self, path, options, cases):
+        _options = ", ".join(options)
+        _cases = ", ".join(cases.keys())
+
+        super().__init__(
+            f"{path}: all options are not covered by cases."
+            f" Options are: {_options}, Cases are: {_cases}"
+        )
+
+
+class SwitchError(Error, ValueError):
+    def __init__(self, path, val, cases):
+        _cases = ", ".join(cases.keys())
+        super().__init__(
+            f"{path}: switch value is set to {val},"
+            f" but no case matched. Cases are: {_cases}"
+        )