ceph-devstack 0.1.0__py3-none-any.whl

ceph_devstack/Dockerfile.selinux

@@ -0,0 +1,20 @@
+FROM quay.io/centos/centos:stream9 as build
+RUN \
+  dnf install -y \
+    policycoreutils-devel \
+    selinux-policy-devel \
+  && dnf clean all
+COPY ceph_devstack/ceph_devstack.te /ceph_devstack/
+RUN \
+  mkdir -p /ceph_devstack && \
+  cd /ceph_devstack && \
+  make \
+    -f \
+    /usr/share/selinux/devel/Makefile \
+    ceph_devstack.pp
+
+FROM scratch
+WORKDIR /ceph_devstack
+COPY --from=build /ceph_devstack/ceph_devstack.pp /ceph_devstack.pp
+COPY --from=build /bin/cat /bin/cat
+ENTRYPOINT /bin/cat

ceph_devstack/__init__.py

@@ -0,0 +1,187 @@
+import argparse
+import logging.config
+import tomlkit
+import tomlkit.items
+import tomlkit.exceptions
+
+from pathlib import Path
+from typing import List
+
+
+VERBOSE = 15
+logging.addLevelName(15, "VERBOSE")
+logging.config.fileConfig(Path(__file__).parent / "logging.conf")
+logger = logging.getLogger("ceph-devstack")
+
+PROJECT_ROOT = Path(__file__).parent
+DEFAULT_CONFIG_PATH = Path("~/.config/ceph-devstack/config.toml")
+
+
+def parse_args(args: List[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        default=False,
+        help="Instead of running commands, print them",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        default=False,
+        help="Be more verbose",
+    )
+    parser.add_argument(
+        "-c",
+        "--config-file",
+        type=Path,
+        default=DEFAULT_CONFIG_PATH,
+        help="Path to the ceph-devstack config file",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    parser_config = subparsers.add_parser("config", help="Get or set config items")
+    subparsers_config = parser_config.add_subparsers(dest="config_op")
+    subparsers_config.add_parser("dump", help="show the configuration")
+    parser_config_get = subparsers_config.add_parser("get")
+    parser_config_get.add_argument("name")
+    parser_config_set = subparsers_config.add_parser("set")
+    parser_config_set.add_argument("name")
+    parser_config_set.add_argument("value")
+    parser_doc = subparsers.add_parser(
+        "doctor", help="Check that the system meets requirements"
+    )
+    parser_doc.add_argument(
+        "--fix",
+        action="store_true",
+        default=False,
+        help="Apply suggested fixes for issues found",
+    )
+    parser_pull = subparsers.add_parser("pull", help="Pull container images")
+    parser_pull.add_argument(
+        "image",
+        nargs="*",
+        help="Specific image(s) to pull",
+    )
+    parser_build = subparsers.add_parser("build", help="Build container images")
+    parser_build.add_argument(
+        "image",
+        nargs="*",
+        help="Specific image(s) to build",
+    )
+    parser_create = subparsers.add_parser(
+        "create",
+        help="Create the cluster",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser_create.add_argument(
+        "-b",
+        "--build",
+        action="store_true",
+        default=False,
+        help="Build images before creating",
+    )
+    parser_create.add_argument(
+        "-w",
+        "--wait",
+        action="store_true",
+        default=False,
+        help="Leave the cluster running - and don't auto-schedule anything",
+    )
+    subparsers.add_parser("remove", help="Destroy the cluster")
+    subparsers.add_parser("start", help="Start the cluster")
+    subparsers.add_parser("stop", help="Stop the cluster")
+    subparsers.add_parser(
+        "watch", help="Monitor the cluster, recreating containers as necessary"
+    )
+    parser_wait = subparsers.add_parser(
+        "wait",
+        help="Wait for the specified container to exit. Exit with its exit code.",
+    )
+    parser_wait.add_argument(
+        "container",
+        help="The container to wait for",
+    )
+    parser_log = subparsers.add_parser("logs", help="Dump teuthology logs")
+    parser_log.add_argument("-r", "--run-name", type=str, default=None)
+    parser_log.add_argument("-j", "--job-id", type=str, default=None)
+    parser_log.add_argument(
+        "--locate",
+        action=argparse.BooleanOptionalAction,
+        help="Display log file path instead of contents",
+    )
+    return parser.parse_args(args)
+
+
+def deep_merge(*maps):
+    result = {}
+    for mapping in maps:
+        for k, v in mapping.items():
+            if isinstance(v, dict):
+                v = deep_merge(result.get(k, {}), v)
+            result[k] = v
+    return result
+
+
+class Config(dict):
+    __slots__ = ["user_obj", "user_path"]
+
+    def load(self, config_path: Path | None = None):
+        parsed = tomlkit.parse((Path(__file__).parent / "config.toml").read_text())
+        self.update(parsed)
+        if config_path:
+            self.user_path = config_path.expanduser()
+            if self.user_path.exists():
+                self.user_obj: dict = tomlkit.parse(self.user_path.read_text()) or {}
+                self.update(deep_merge(config, self.user_obj))
+            elif self.user_path != DEFAULT_CONFIG_PATH.expanduser():
+                raise OSError(f"Config file at {self.user_path} not found!")
+            else:
+                self.user_obj = {}
+
+    def dump(self):
+        return tomlkit.dumps(self)
+
+    def get_value(self, name: str) -> str:
+        path = name.split(".")
+        obj = config
+        i = 0
+        while i < len(path):
+            sub_path = path[i]
+            try:
+                obj = obj[sub_path]
+            except KeyError:
+                logger.error(f"{name} not found in config")
+                raise
+            i += 1
+        if isinstance(obj, (str, int, bool)):
+            return str(obj)
+        return tomlkit.dumps(obj).strip()
+
+    def set_value(self, name: str, value: str) -> None:
+        path = name.split(".")
+        obj = self.user_obj
+        i = 0
+        last_index = len(path) - 1
+        try:
+            item = tomlkit.value(value)
+        except (
+            tomlkit.exceptions.UnexpectedCharError,
+            tomlkit.exceptions.InternalParserError,
+        ):
+            item = tomlkit.item(value)
+        while i <= last_index:
+            if i < last_index:
+                obj = obj.setdefault(path[i], {})
+            elif i == last_index:
+                obj[path[i]] = item
+                self.update(self.user_obj)
+                self.user_path.parent.mkdir(exist_ok=True)
+                self.user_path.write_text(tomlkit.dumps(self.user_obj).strip())
+            i += 1
+
+
+config = Config()
+config.load()

ceph_devstack/ceph_devstack.te

@@ -0,0 +1,127 @@
+module ceph_devstack 1.0;
+
+require {
+	type unconfined_t;
+	type container_t;
+	type container_init_t;
+	type proc_t;
+	type sysfs_t;
+	type tmpfs_t;
+	type user_tmp_t;
+	type devpts_t;
+	class filesystem mount;
+	class filesystem unmount;
+
+	type null_device_t;
+	type zero_device_t;
+	type devtty_t;
+	type random_device_t;
+	type urandom_device_t;
+	class chr_file mounton;
+
+	class dir mounton;
+
+	type proc_kcore_t;
+	class file mounton;
+
+	type device_t;
+	class filesystem remount;
+
+	type sysctl_irq_t;
+
+	type fixed_disk_device_t;
+	class blk_file setattr;
+	class blk_file mounton;
+
+	type fs_t;
+
+	type cgroup_t;
+
+	type sysctl_t;
+
+	type unlabeled_t;
+	class chr_file getattr;
+	class chr_file setattr;
+	class chr_file unlink;
+
+	type kernel_t;
+	class system syslog_read;
+
+	type iptables_t;
+	type container_file_t;
+	class dir ioctl;
+
+	type init_t;
+	type unconfined_service_t;
+	class process siginh;
+
+	type chkpwd_t;
+	type user_devpts_t;
+	class chr_file { read write };
+
+	type proc_kmsg_t;
+
+	type ramfs_t;
+
+	type sysctl_kernel_t;
+	class dir read;
+
+	type system_map_t;
+
+	type mtrr_device_t;
+
+	class bpf prog_load;
+	class bpf map_create;
+
+	type lvm_control_t;
+	type fuse_device_t;
+
+	type tun_tap_device_t;
+
+	class sock_file write;
+	class unix_stream_socket connectto;
+}
+
+#============= container_init_t ==============
+allow container_init_t proc_t:filesystem { mount unmount remount };
+allow container_init_t sysfs_t:filesystem { mount unmount remount };
+allow container_init_t tmpfs_t:filesystem { mount unmount remount };
+allow container_init_t devpts_t:filesystem mount;
+allow container_init_t null_device_t:chr_file { mounton setattr };
+allow container_init_t zero_device_t:chr_file mounton;
+allow container_init_t devtty_t:chr_file mounton;
+allow container_init_t random_device_t:chr_file mounton;
+allow container_init_t urandom_device_t:chr_file mounton;
+allow container_init_t proc_t:dir mounton;
+allow container_init_t proc_kcore_t:file mounton;
+allow container_init_t device_t:filesystem { unmount remount};
+allow container_init_t proc_t:file mounton;
+allow container_init_t sysctl_irq_t:dir mounton;
+allow container_init_t fixed_disk_device_t:blk_file setattr;
+allow container_init_t fs_t:filesystem remount;
+allow container_init_t cgroup_t:filesystem remount;
+allow container_init_t sysctl_t:dir mounton;
+allow container_init_t sysctl_t:file mounton;
+allow container_init_t unlabeled_t:chr_file { getattr unlink };
+allow container_init_t kernel_t:system syslog_read;
+allow iptables_t container_file_t:dir ioctl;
+allow init_t unconfined_service_t:process siginh;
+allow chkpwd_t user_devpts_t:chr_file { read write };
+allow container_init_t proc_kmsg_t:file mounton;
+allow container_init_t ramfs_t:filesystem mount;
+allow init_t chkpwd_t:process siginh;
+allow container_init_t ramfs_t:dir read;
+allow container_init_t sysctl_kernel_t:file mounton;
+allow container_init_t devpts_t:filesystem remount;
+allow container_init_t system_map_t:file mounton;
+allow container_init_t system_map_t:file mounton;
+allow container_init_t mtrr_device_t:file mounton;
+allow container_init_t self:bpf prog_load;
+allow container_init_t self:bpf map_create;
+allow container_init_t lvm_control_t:chr_file mounton;
+allow container_init_t fuse_device_t:chr_file mounton;
+allow container_init_t fixed_disk_device_t:blk_file mounton;
+allow container_init_t tun_tap_device_t:chr_file mounton;
+
+allow container_t user_tmp_t:sock_file write;
+allow container_t unconfined_t:unix_stream_socket connectto;

ceph_devstack/cli.py

@@ -0,0 +1,64 @@
+import asyncio
+import logging
+import sys
+
+from pathlib import Path
+
+from ceph_devstack import config, logger, parse_args, VERBOSE
+from ceph_devstack.requirements import check_requirements
+from ceph_devstack.resources.ceph import CephDevStack
+
+CONFIG_HANDLERS = {
+    "dump": lambda config, args: print(config.dump()),
+    "get": lambda config, args: print(config.get_value(args.name)),
+    "set": lambda config, args: print(config.set_value(args.name, args.value)),
+}
+
+COMMAND_HANDLERS = {
+    "doctor": None,
+    "apply": lambda args, obj: obj.apply(args.command),
+    "pull": lambda _, obj: obj.pull(),
+    "build": lambda _, obj: obj.build(),
+    "create": lambda _, obj: obj.create(),
+    "remove": lambda _, obj: obj.remove(),
+    "start": lambda _, obj: obj.start(),
+    "stop": lambda _, obj: obj.stop(),
+    "watch": lambda _, obj: obj.watch(),
+    "wait": lambda args, obj: obj.wait(container_name=args.container),
+    "logs": lambda args, obj: obj.logs(
+        run_name=args.run_name, job_id=args.job_id, locate=args.locate
+    ),
+}
+
+
+def main() -> int:
+    args = parse_args(sys.argv[1:])
+    config.load(args.config_file)
+    if args.verbose:
+        for handler in logging.getLogger("root").handlers:
+            if not isinstance(handler, logging.FileHandler):
+                handler.setLevel(VERBOSE)
+    if args.command == "config":
+        CONFIG_HANDLERS[args.config_op](config, args)
+        return 0
+    config["args"] = vars(args)
+    data_path = Path(config["data_dir"]).expanduser()
+    data_path.mkdir(parents=True, exist_ok=True)
+    obj = CephDevStack()
+
+    async def run():
+        if not await asyncio.gather(
+            check_requirements(),
+            obj.check_requirements(),
+        ):
+            logger.error("Requirements not met!")
+            return 1
+        handler = COMMAND_HANDLERS.get(args.command)
+        if handler:
+            return await handler(args, obj)
+
+    try:
+        sys.exit(asyncio.run(run()))
+    except KeyboardInterrupt:
+        logger.debug("Exiting!")
+        return 130  # 128 + SIGINT

ceph_devstack/config.toml

@@ -0,0 +1,24 @@
+data_dir = "~/.local/share/ceph-devstack"
+
+[containers.archive]
+image = "python:alpine"
+
+[containers.beanstalk]
+image = "quay.io/ceph-infra/teuthology-beanstalkd:main"
+
+[containers.paddles]
+image = "quay.io/ceph-infra/paddles:main"
+
+[containers.postgres]
+image = "quay.io/ceph-infra/teuthology-postgresql:latest"
+
+[containers.pulpito]
+image = "quay.io/ceph-infra/pulpito:main"
+
+[containers.testnode]
+count = 3
+loop_device_size = "5G"
+image = "quay.io/ceph-infra/teuthology-testnode:main"
+
+[containers.teuthology]
+image = "quay.io/ceph-infra/teuthology-dev:main"

ceph_devstack/exec.py

@@ -0,0 +1,93 @@
+import asyncio
+from asyncio.subprocess import SubprocessStreamProtocol
+import functools
+import os
+import pathlib
+import subprocess
+
+from typing import Dict, List, Optional
+
+from ceph_devstack import logger, VERBOSE
+
+
+class LoggingStreamProtocol(asyncio.subprocess.SubprocessStreamProtocol):
+    def __init__(self, limit, loop, log_level):
+        self.log_level = log_level
+        super().__init__(limit=limit, loop=loop)
+
+    def pipe_data_received(self, fd, data):
+        logger.log(
+            self.log_level,
+            (data.decode() if isinstance(data, bytes) else str(data)).rstrip("\n"),
+        )
+        super().pipe_data_received(fd, data)
+
+
+class Command:
+    def __init__(
+        self,
+        args: List[str],
+        cwd: Optional[pathlib.Path] = None,
+        env: Optional[Dict] = None,
+        stream_output: bool = False,
+    ):
+        self.args = args
+        self.env = os.environ | (env or {})
+        self.kwargs: Dict = {
+            "stdout": asyncio.subprocess.PIPE,
+            "stderr": asyncio.subprocess.PIPE,
+        }
+        if cwd:
+            self.kwargs.update(cwd=cwd)
+        self.stream_output = stream_output
+
+    def _make_log_msg(self) -> str:
+        msg = "> " + " ".join(self.args)
+        if (cwd := str(self.kwargs.get("cwd", "."))) != ".":
+            msg = f"{msg} cwd='{cwd}'"
+        return msg
+
+    def run(self) -> subprocess.Popen:
+        logger.log(VERBOSE, self._make_log_msg())
+        proc = subprocess.Popen(
+            args=self.args,
+            env=self.env,
+            **self.kwargs,
+        )
+        proc.wait()
+        return proc
+
+    async def arun(self) -> asyncio.subprocess.Process:
+        logger.log(VERBOSE, self._make_log_msg())
+        loop = asyncio.get_running_loop()
+        protocol_factory: (
+            functools.partial[SubprocessStreamProtocol]
+            | functools.partial[LoggingStreamProtocol]
+        )
+        if self.stream_output:
+            protocol_factory = functools.partial(
+                LoggingStreamProtocol,
+                limit=2**16,
+                loop=loop,
+                log_level=VERBOSE,
+            )
+        else:
+            protocol_factory = functools.partial(
+                asyncio.subprocess.SubprocessStreamProtocol,
+                limit=2**16,
+                loop=loop,
+            )
+        transport, protocol = await loop.subprocess_exec(
+            protocol_factory,
+            *self.args,
+            env=self.env,
+            **self.kwargs,
+        )
+        return asyncio.subprocess.Process(
+            transport,
+            protocol,
+            loop,
+        )
+
+    def __str__(self):
+        return " ".join(self.args)

ceph_devstack/host.py

@@ -0,0 +1,154 @@
+import asyncio
+import logging
+import os
+import pathlib
+import socket
+import sys
+import yaml
+
+from packaging.version import parse as parse_version, Version
+from typing import Dict, List, Optional, Union
+
+from .exec import Command
+
+logger = logging.getLogger(__name__)
+
+
+class Host:
+    type = "local"
+
+    def cmd(
+        self,
+        args: List[str],
+        cwd: Optional[pathlib.Path] = None,
+        env: Optional[Dict] = None,
+        stream_output: bool = False,
+    ) -> Command:
+        return Command(
+            args,
+            cwd=cwd,
+            env=env,
+            stream_output=stream_output,
+        )
+
+    def run(
+        self,
+        args: List[str],
+        cwd: Optional[pathlib.Path] = None,
+        env: Optional[Dict] = None,
+    ):
+        return self.cmd(args, cwd=cwd, env=env).run()
+
+    async def arun(
+        self,
+        args: List[str],
+        cwd: Optional[pathlib.Path] = None,
+        env: Optional[Dict] = None,
+        stream_output: bool = False,
+    ) -> asyncio.subprocess.Process:
+        return await self.cmd(
+            args, cwd=cwd, env=env, stream_output=stream_output
+        ).arun()
+
+    def path_exists(self, path: Union[str, pathlib.Path]):
+        if isinstance(path, pathlib.Path):
+            return path.exists()
+        return os.path.exists(path)
+
+    def hostname(self) -> str:
+        name = socket.getfqdn()
+        try:
+            socket.gethostbyname(name)
+            return name
+        except socket.gaierror:
+            return "localhost"
+
+    def kernel_version(self) -> Version:
+        if not hasattr(self, "_kernel_version"):
+            proc = self.run(["uname", "-r"])
+            assert proc.stdout is not None
+            assert proc.wait() == 0, "`uname -r` failed?!"
+            raw_version = proc.stdout.read().decode().strip()
+            self._kernel_version = parse_version(raw_version.split("-")[0])
+        return self._kernel_version
+
+    def os_type(self) -> str:
+        if not hasattr(self, "_os_type"):
+            proc = self.run(["bash", "-c", ". /etc/os-release && echo $ID"])
+            assert proc.stdout is not None
+            assert proc.wait() == 0, "is /etc/os-release missing?"
+            self._os_type = proc.stdout.read().decode().strip().lower()
+        return self._os_type
+
+    async def podman_info(self, force: bool = False) -> Dict:
+        if force or not hasattr(self, "_podman_info"):
+            proc = await self.arun(["podman", "info"])
+            assert proc.stdout is not None
+            await proc.wait()
+            stdout = await proc.stdout.read()
+            self._podman_info = yaml.safe_load(stdout.decode().strip())
+        return self._podman_info
+
+    async def selinux_enforcing(self) -> bool:
+        proc = await host.arun(["cat", "/sys/fs/selinux/enforce"])
+        assert proc.stdout is not None
+        await proc.wait()
+        out = (await proc.stdout.read()).decode()
+        return proc.returncode == 0 and out == "1"
+
+    async def check_selinux_bool(self, name: str):
+        proc = await host.arun(["getsebool", name])
+        assert proc.stdout is not None
+        out = await proc.stdout.read()
+        return out.decode().strip() == f"{name} --> on"
+
+    async def get_sysctl_value(self, name: str) -> int:
+        proc = await host.arun(["sysctl", "-b", name])
+        assert proc.stdout is not None
+        out = await proc.stdout.read()
+        return int(out.decode().strip())
+
+    async def apparmor_enabled(self) -> bool:
+        try:
+            proc = await host.arun(["aa-enabled", "-q"])
+        except FileNotFoundError:
+            return False
+        return await proc.wait() == 0
+
+
+class LocalHost(Host):
+    pass
+
+
+class RemoteHost(Host):
+    type = "remote"
+    base_args = ["podman", "machine", "ssh", "--"]
+
+    def cmd(
+        self,
+        args: List[str],
+        cwd: Optional[pathlib.Path] = None,
+        env: Optional[Dict] = None,
+        stream_output: bool = False,
+    ):
+        if args[0] != "podman":
+            args = self.base_args + args
+        return super().cmd(args, cwd=cwd, env=env, stream_output=stream_output)
+
+    def path_exists(self, path: Union[str, pathlib.Path]):
+        path = os.path.expanduser(path)
+        proc = host.run(["ls", path])
+        return proc.returncode == 0
+
+    def hostname(self) -> str:
+        proc = self.run(["hostname"])
+        assert proc.stdout is not None
+        return proc.stdout.read().decode().strip()
+
+
+local_host = LocalHost()
+
+if sys.platform == "darwin":
+    host = RemoteHost()
+else:
+    host = local_host

ceph_devstack/logging.conf

@@ -0,0 +1,30 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=consoleHandler,fileHandler
+
+[formatters]
+keys=bareFormatter,simpleFormatter
+
+[logger_root]
+level=DEBUG
+handlers=consoleHandler,fileHandler
+
+[handler_consoleHandler]
+class=StreamHandler
+level=INFO
+formatter=bareFormatter
+args=(sys.stdout,)
+
+[handler_fileHandler]
+class=FileHandler
+level=DEBUG
+formatter=simpleFormatter
+args=('/tmp/ceph-devstack.log', 'w')
+
+[formatter_bareFormatter]
+format=%(message)s
+
+[formatter_simpleFormatter]
+format=%(asctime)s %(levelname)s:%(name)s:%(message)s