318 lines
10 KiB
Python
318 lines
10 KiB
Python
#!/usr/bin/env python3.11
|
|
import argparse
|
|
import json
|
|
import logging
|
|
import re
|
|
import shlex
|
|
import subprocess
|
|
import sys
|
|
from argparse import ArgumentParser
|
|
|
|
from dataclasses import asdict, dataclass, field, fields
|
|
from functools import reduce
|
|
from operator import concat
|
|
from typing import Dict, Generic, Iterable, List, Optional, TypeVar
|
|
|
|
DEFAULT_MACHINE = "podman-machine-default"
|
|
T = TypeVar("T")
|
|
logger = logging.getLogger("podman-launchd")
|
|
logger_commander = logger.getChild("commander")
|
|
|
|
CAMEL_REGEX = re.compile(r"([A-Z]+)")
|
|
UNDERSCORE_REGEX = re.compile(r"^_")
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Machine:
|
|
# Resource config for CLI
|
|
cpus: int
|
|
disk_size: int
|
|
memory: int
|
|
|
|
# Metadata about the machine
|
|
name: str
|
|
active: bool = field(compare=False, default=False)
|
|
qemu_binary: Optional[str] = None
|
|
"""A path to a custom QEMU command to be used when starting the machine with a specific arch"""
|
|
|
|
# Optional CLI parameters
|
|
image_path: Optional[str] = None
|
|
"""A local path to a custom QEMU image"""
|
|
|
|
@classmethod
|
|
def from_dict(cls, a_dict: dict) -> "Machine":
|
|
return Machine(
|
|
**{
|
|
snake_key: value
|
|
for key, value in a_dict.items()
|
|
if (snake_key := camel2snake(key).lower()) in MACHINE_FIELDS
|
|
}
|
|
)
|
|
|
|
|
|
MACHINE_FIELDS = [field.name for field in fields(Machine)]
|
|
|
|
|
|
@dataclass
|
|
class Diff(Generic[T]):
|
|
new: List[T] = field(default_factory=list)
|
|
modified: List[T] = field(default_factory=list)
|
|
same: List[T] = field(default_factory=list)
|
|
removed: List[T] = field(default_factory=list)
|
|
|
|
|
|
class PodmanMachineCommander:
|
|
MACHINE_CLI_ARGS = ("cpus", "disk_size", "memory")
|
|
|
|
def __init__(self, command: str = None):
|
|
self.command = command or "podman"
|
|
|
|
def _call(self, *args: str, **kwargs) -> str:
|
|
"""Call podman machine"""
|
|
|
|
args_ = [self.command, "machine"] + list(args)
|
|
logger_commander.debug("Executing %s", shlex.join(args_))
|
|
|
|
# no subprocess.run here as streaming is necessary
|
|
stdout_lines = []
|
|
with subprocess.Popen(
|
|
args_,
|
|
# Capture both streams in stdout
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
**kwargs,
|
|
) as process:
|
|
# Collect stdout+stderr and steam if requested
|
|
for line in process.stdout:
|
|
line_str = line.decode().rstrip()
|
|
stdout_lines.append(line_str)
|
|
logger_commander.debug(line_str)
|
|
|
|
stdout = "\n".join(stdout_lines)
|
|
# Check if the command failed
|
|
if (return_code := process.returncode) != 0:
|
|
print(stdout, file=sys.stderr)
|
|
raise subprocess.CalledProcessError(return_code, args_, stdout)
|
|
|
|
return stdout
|
|
|
|
def _call_json(self, *args: str, **kwargs) -> dict:
|
|
"""Call podman requesting JSON output and interpret it as such"""
|
|
return json.loads(self._call(*args, "--format", "json", **kwargs))
|
|
|
|
@classmethod
|
|
def make_cli_args(
|
|
cls, machine: Machine, selected_args: Iterable[str] = MACHINE_CLI_ARGS
|
|
):
|
|
"""
|
|
Converts dict from list of key-value pair
|
|
to list of ["--key1", value1, "--key2", value2, ... ]
|
|
"""
|
|
machine_dict = asdict(machine)
|
|
return reduce(
|
|
concat,
|
|
[
|
|
[("--" + key.replace("_", "-")), str(value)]
|
|
for key in selected_args
|
|
if (value := machine_dict.get(key))
|
|
],
|
|
[],
|
|
)
|
|
|
|
def get_active_machine_name(self) -> str:
|
|
"""Name of the machine that is currently running"""
|
|
output_json = self._call_json("info")
|
|
return output_json.get("Host", {}).get("CurrentMachine")
|
|
|
|
def list(self) -> Dict[str, Machine]:
|
|
"""Get all machines known to podman"""
|
|
machine_jsons = self._call_json("list")
|
|
if not isinstance(machine_jsons, list):
|
|
raise ValueError("Unexpected output from command", machine_jsons)
|
|
|
|
# `podman machine list` has different units for disk_size, memory, etc.
|
|
# `podman machine inspect` has the information we need
|
|
inspected_jsons = self.inspect(
|
|
*[listed_machine["Name"] for listed_machine in machine_jsons]
|
|
)
|
|
return {
|
|
machine.name: machine
|
|
for inspected_json in inspected_jsons
|
|
if (
|
|
machine := Machine.from_dict(
|
|
{"name": inspected_json["Name"], **inspected_json["Resources"]}
|
|
)
|
|
)
|
|
}
|
|
|
|
def inspect(self, *machine_names: str):
|
|
"""Get information about a machine from podman"""
|
|
# The podman machine interface is really confusing
|
|
# inspect only returns JSON and other commands require --format json
|
|
return json.loads(self._call("inspect", *machine_names))
|
|
|
|
def add(self, machine: Machine):
|
|
"""
|
|
Let podman create a machine's config and initialize it
|
|
Also downloads the image of the machine
|
|
"""
|
|
self._call(
|
|
"init",
|
|
*self.make_cli_args(machine, self.MACHINE_CLI_ARGS + ("image_path",)),
|
|
machine.name,
|
|
)
|
|
|
|
def update(self, machine: Machine):
|
|
"""Update a machine's configuration and write it to disk"""
|
|
self._call("set", *self.make_cli_args(machine), machine.name)
|
|
|
|
# Set the custom QEMU path in the machine's config
|
|
# This is necessary for running machines with a specific architecture
|
|
if machine.qemu_binary:
|
|
inspection = self.inspect(machine.name)[0]
|
|
config_path = inspection.get("ConfigPath", {}).get("Path", {})
|
|
|
|
with open(config_path) as config_file:
|
|
config = json.load(config_file)
|
|
|
|
if not (cmd_line := config.get("CmdLine")):
|
|
logger.error(
|
|
"Cannot find CmdLine in config of %s at", machine.name, config_path
|
|
)
|
|
cmd_line[0] = machine.qemu_binary
|
|
|
|
with open(config_path, mode="w") as config_file:
|
|
json.dump(config, config_file)
|
|
|
|
def remove(self, machine: Machine):
|
|
"""Kills and removes the machine"""
|
|
self._call("rm", "--force", machine.name)
|
|
|
|
def start(self, machine_name: str):
|
|
"""Start up a machine"""
|
|
self._call("start", machine_name)
|
|
|
|
def stop(self, machine_name: str):
|
|
"""Stop a running machine"""
|
|
self._call("stop", machine_name)
|
|
|
|
|
|
def main(
|
|
requested_machines: Dict[str, Machine],
|
|
podman_command: str,
|
|
):
|
|
"""
|
|
:param requested_machines: Which machines should exist on the host
|
|
:param podman_command: The path to or the podman command itself
|
|
"""
|
|
podman_command = podman_command or "podman"
|
|
commander = PodmanMachineCommander(podman_command)
|
|
active_machines = [
|
|
name for name, machine in requested_machines.items() if machine.active
|
|
]
|
|
if len(active_machines) != 1:
|
|
raise ValueError("Exactly one machine in the configuration should be active")
|
|
requested_active = active_machines[0]
|
|
|
|
old_machines = commander.list()
|
|
# Find machines to add, update, delete
|
|
diffs = diff_machines(requested_machines, old_machines)
|
|
|
|
# Init new machines
|
|
for new_machine in diffs.new:
|
|
logger.info("Adding machine: %s. This may take some time...", new_machine.name)
|
|
commander.add(new_machine)
|
|
# Init the default machine if it's not
|
|
|
|
# Delete old ones
|
|
for removed_machine in diffs.removed:
|
|
logger.info("Removing machine: %s", removed_machine.name)
|
|
commander.remove(removed_machine)
|
|
|
|
# Update configuration of qemuBinary if necessary
|
|
for mod_machine in diffs.modified:
|
|
logger.info("Updating machine: %s", mod_machine.name)
|
|
commander.update(mod_machine)
|
|
|
|
# Start the requested machine if it isn't already running
|
|
active_machine = commander.get_active_machine_name()
|
|
if active_machine != requested_active:
|
|
if active_machine:
|
|
logger.info("Stopping machine: %s", active_machine)
|
|
commander.stop(active_machine)
|
|
logger.info("Starting: %s", requested_active)
|
|
commander.start(requested_active)
|
|
|
|
logger.info("%s is active and podman is ready to be used")
|
|
|
|
|
|
def camel2snake(camel: str) -> str:
|
|
"""
|
|
Converts camelCase to snake_case
|
|
"""
|
|
snake = CAMEL_REGEX.sub(r"_\1", camel).lower()
|
|
# if snake starts with _ remove it
|
|
return UNDERSCORE_REGEX.sub("", snake)
|
|
|
|
|
|
def diff_machines(
|
|
requested_machines: Dict[str, Machine], old_machines: Dict[str, Machine]
|
|
) -> Diff[Machine]:
|
|
diff: Diff[Machine] = Diff()
|
|
requested_names = requested_machines.keys()
|
|
old_names = old_machines.keys()
|
|
requested_items = requested_machines.items()
|
|
old_items = old_machines.items()
|
|
diff.new = [requested_machines[name] for name in (requested_names - old_names)]
|
|
diff.removed = [old_machines[name] for name in (old_names - requested_names)]
|
|
diff.same = list(dict(old_items & requested_items).values())
|
|
|
|
# Find modified machines = same key, different Machine
|
|
diff.modified = [
|
|
requested_machines[key]
|
|
for key in (requested_names & old_names)
|
|
if requested_machines[key] != old_machines[key]
|
|
]
|
|
|
|
return diff
|
|
|
|
|
|
def MachineDict(json_path: str) -> dict:
|
|
try:
|
|
with open(json_path) as json_file:
|
|
loaded_json = json.load(json_file)
|
|
return {
|
|
name: Machine.from_dict({"name": name, **machine})
|
|
for name, machine in loaded_json.items()
|
|
}
|
|
except json.JSONDecodeError as decode_error:
|
|
raise argparse.ArgumentTypeError() from decode_error
|
|
except Exception as exc:
|
|
raise argparse.ArgumentTypeError() from exc
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = ArgumentParser(
|
|
"podman-launchd", description="CRUDs pod machines and starts one"
|
|
)
|
|
|
|
parser.add_argument(
|
|
"machines",
|
|
help="Path to JSON configuration of machines that should be on this host",
|
|
type=MachineDict,
|
|
)
|
|
parser.add_argument(
|
|
"-p", "--podman", help="Name or path of the podman command to use"
|
|
)
|
|
parser.add_argument(
|
|
"--verbose", help="Activate verbose logging", action="store_true"
|
|
)
|
|
cmd_args = parser.parse_args()
|
|
logging.basicConfig(level=logging.DEBUG if cmd_args.verbose else logging.INFO)
|
|
|
|
try:
|
|
main(cmd_args.machines, cmd_args.podman)
|
|
except:
|
|
logger.exception("Couldn't complete command")
|
|
exit(1)
|