109 lines
3.9 KiB
Python
109 lines
3.9 KiB
Python
import logging
|
|
import shutil
|
|
from collections.abc import Iterator
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
|
|
from clan_lib.dirs import specific_machine_dir
|
|
from clan_lib.errors import ClanError
|
|
from clan_lib.flake import Flake
|
|
from clan_lib.machines.actions import MachineID, list_machines
|
|
from clan_lib.templates.filesystem import copy_from_nixstore, realize_nix_path
|
|
from clan_lib.templates.template_url import transform_url
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
@contextmanager
|
|
def machine_template(
|
|
flake: Flake, template_ident: str, dst_machine_name: str
|
|
) -> Iterator[Path]:
|
|
"""
|
|
Create a machine from a template.
|
|
This function will copy the template files to the machine specific directory of the specified flake.
|
|
|
|
:param flake: The flake to create the machine in.
|
|
:param template_ident: The identifier of the template to use. Example ".#template_name"
|
|
:param dst_machine_name: The name of the machine to create.
|
|
|
|
Example usage:
|
|
|
|
>>> with machine_template(
|
|
... Flake("/home/johannes/git/clan-core"), ".#new-machine", "my-machine"
|
|
... ) as machine_path:
|
|
... # Use `machine_path` here if you want to access the created machine directory
|
|
|
|
... The machine directory is removed if the context raised any errors.
|
|
... Only if the context is exited without errors, the machine directory is kept.
|
|
"""
|
|
|
|
# Check for duplicates
|
|
if dst_machine_name in list_machines(flake):
|
|
msg = f"Machine '{dst_machine_name}' already exists"
|
|
raise ClanError(
|
|
msg,
|
|
description="Please remove the existing machine or choose a different name",
|
|
)
|
|
|
|
# Get the clan template from the specifier
|
|
[flake_ref, template_selector] = transform_url(
|
|
"machine", template_ident, flake=flake
|
|
)
|
|
# For pretty error messages
|
|
printable_template_ref = f"{flake_ref}#{template_selector}"
|
|
|
|
template_flake = Flake(flake_ref)
|
|
try:
|
|
template = template_flake.select(template_selector)
|
|
except ClanError as e:
|
|
msg = f"Failed to select template '{template_ident}' from flake '{flake_ref}' (via attribute path: {printable_template_ref})"
|
|
raise ClanError(msg) from e
|
|
|
|
src = template.get("path")
|
|
if not src:
|
|
msg = f"Malformed template: {printable_template_ref} does not have a 'path' attribute"
|
|
raise ClanError(msg)
|
|
|
|
src_path = Path(src).resolve()
|
|
|
|
realize_nix_path(template_flake, str(src_path))
|
|
|
|
if not src_path.exists():
|
|
msg = f"Template {printable_template_ref} does not exist at {src_path}"
|
|
raise ClanError(msg)
|
|
|
|
if not src_path.is_dir():
|
|
msg = f"Template {printable_template_ref} is not a directory at {src_path}"
|
|
raise ClanError(msg)
|
|
|
|
# TODO: Do we really need to check for a specific file in the template?
|
|
if not (src_path / "configuration.nix").exists():
|
|
msg = f"Template {printable_template_ref} does not contain a configuration.nix"
|
|
raise ClanError(
|
|
msg,
|
|
description="Template machine must contain a configuration.nix",
|
|
)
|
|
|
|
tmp_machine = MachineID(flake=flake, name=dst_machine_name)
|
|
|
|
dst_machine_dir = specific_machine_dir(tmp_machine)
|
|
|
|
dst_machine_dir.parent.mkdir(exist_ok=True, parents=True)
|
|
|
|
copy_from_nixstore(src_path, dst_machine_dir)
|
|
|
|
try:
|
|
yield dst_machine_dir
|
|
except Exception as e:
|
|
log.error(f"An error occurred inside the 'machine_template' context: {e}")
|
|
|
|
# Ensure that the directory is removed to avoid half-created machines
|
|
# Everything in the with block is considered part of the context
|
|
# So if the context raises an error, we clean up the machine directory
|
|
log.info(f"Removing left-over machine directory: {dst_machine_dir}")
|
|
shutil.rmtree(dst_machine_dir, ignore_errors=True)
|
|
raise
|
|
finally:
|
|
# If no error occurred, the machine directory is kept
|
|
pass
|