clean_package_manager_metadata,
finalize_package_manager_mounts,
package_manager_scripts,
- rchown_package_manager_cache_dirs,
)
from mkosi.kmod import gen_required_kernel_modules, process_kernel_modules
from mkosi.log import ARG_DEBUG, complete_step, die, log_notice, log_step
"--cache-only", str(context.config.cache_only),
"--output-dir", str(context.workspace / "initrd"),
*(["--workspace-dir", str(context.config.workspace_dir)] if context.config.workspace_dir else []),
- *(["--cache-dir", str(context.config.cache_dir)] if context.config.cache_dir else []),
- *(["--package-cache-dir", str(context.config.package_cache_dir)] if context.config.package_cache_dir else []),
+ "--cache-dir", str(context.cache_dir),
*(["--local-mirror", str(context.config.local_mirror)] if context.config.local_mirror else []),
"--incremental", str(context.config.incremental),
"--acl", str(context.config.acl),
*(["--output-dir", str(config.output_dir)] if config.output_dir else []),
*(["--workspace-dir", str(config.workspace_dir)] if config.workspace_dir else []),
*(["--cache-dir", str(config.cache_dir)] if config.cache_dir else []),
- *(["--package-cache-dir", str(config.package_cache_dir)] if config.package_cache_dir else []),
"--incremental", str(config.incremental),
"--acl", str(config.acl),
*([f"--package={package}" for package in config.tools_tree_packages]),
with complete_step(f"Clearing out build directory of {config.name()} image…"):
rmtree(*config.build_dir.iterdir())
- if (
- remove_package_cache and
- config.package_cache_dir and
- config.package_cache_dir.exists() and
- any(config.package_cache_dir.iterdir())
- ):
+ if remove_package_cache and config.cache_dir and config.cache_dir.exists() and any(config.cache_dir.iterdir()):
with complete_step(f"Clearing out package cache of {config.name()} image…"):
rmtree(
*(
- config.package_cache_dir / p / d
+ config.cache_dir / p / d
for p in ("cache", "lib")
for d in ("apt", "dnf", "libdnf5", "pacman", "zypp")
),
if Path(d).exists():
run(["mount", "--rbind", d, d, "--options", "ro"])
- # Create these as the invoking user to make sure they're owned by the user running mkosi.
- for p in (
- config.output_dir,
- config.cache_dir,
- config.package_cache_dir_or_default(),
- config.package_state_dir_or_default(),
- config.build_dir,
- config.workspace_dir,
- ):
- if p:
- INVOKING_USER.mkdir(p)
-
with (
complete_step(f"Building {config.name()} image"),
prepend_to_environ_path(config),
- acl_toggle_build(config, INVOKING_USER.uid),
- rchown_package_manager_cache_dirs(config),
):
+ # After tools have been mounted, check if we have what we need
check_tools(config, Verb.build)
- build_image(args, config, resources=resources)
+
+ # Create these as the invoking user to make sure they're owned by the user running mkosi.
+ for p in (
+ config.output_dir,
+ config.cache_dir,
+ config.build_dir,
+ config.workspace_dir,
+ ):
+ if p:
+ run(["mkdir", "--parents", p], user=INVOKING_USER.uid, group=INVOKING_USER.gid)
+
+ with acl_toggle_build(config, INVOKING_USER.uid):
+ build_image(args, config, resources=resources)
def run_verb(args: Args, images: Sequence[Config], *, resources: Path) -> None:
output_dir: Optional[Path]
workspace_dir: Optional[Path]
cache_dir: Optional[Path]
- package_cache_dir: Optional[Path]
build_dir: Optional[Path]
image_id: Optional[str]
image_version: Optional[str]
if self.workspace_dir:
return self.workspace_dir
- if (cache := INVOKING_USER.cache_dir()) and cache != Path("/var/cache"):
- return cache
+ if (cache := os.getenv("XDG_CACHE_HOME")) and Path(cache).exists():
+ return Path(cache)
+
+ # If we're running from /home and there's a cache or output directory in /home, we want to use a workspace
+ # directory in /home as well as /home might be on a separate partition or subvolume which means that to take
+ # advantage of reflinks and such, the workspace directory has to be on the same partition/subvolume.
+ if (
+ Path.cwd().is_relative_to(INVOKING_USER.home()) and
+ (INVOKING_USER.home() / ".cache").exists() and
+ (
+ self.cache_dir and self.cache_dir.is_relative_to(INVOKING_USER.home()) or
+ self.output_dir and self.output_dir.is_relative_to(INVOKING_USER.home())
+ )
+ ):
+ return INVOKING_USER.home() / ".cache"
return Path("/var/tmp")
- def package_cache_dir_or_default(self) -> Path:
- return self.package_cache_dir or INVOKING_USER.cache_dir()
-
- def package_state_dir_or_default(self) -> Path:
- return self.package_cache_dir or INVOKING_USER.state_dir()
-
def tools(self) -> Path:
return self.tools_tree or Path("/")
section="Output",
parse=config_make_path_parser(required=False),
paths=("mkosi.cache",),
- help="Incremental cache directory",
- ),
- ConfigSetting(
- dest="package_cache_dir",
- metavar="PATH",
- name="PackageCacheDirectory",
- section="Output",
- parse=config_make_path_parser(required=False),
- help="Package cache directory",
+ help="Package cache path",
),
ConfigSetting(
dest="build_dir",
Output Directory: {config.output_dir_or_cwd()}
Workspace Directory: {config.workspace_dir_or_default()}
Cache Directory: {none_to_none(config.cache_dir)}
- Package Cache Directory: {none_to_default(config.package_cache_dir)}
Build Directory: {none_to_none(config.build_dir)}
Image ID: {config.image_id}
Image Version: {config.image_version}
self.pkgmngr.mkdir()
self.packages.mkdir()
self.install_dir.mkdir(exist_ok=True)
+ self.cache_dir.mkdir(parents=True, exist_ok=True)
@property
def root(self) -> Path:
def packages(self) -> Path:
return self.workspace / "packages"
+ @property
+ def cache_dir(self) -> Path:
+ return self.config.cache_dir or (self.workspace / "cache")
+
@property
def install_dir(self) -> Path:
return self.workspace / "dest"
with (
# The deb paths will be in the form of "/var/cache/apt/<deb>" so we transform them to the corresponding
# path in mkosi's package cache directory.
- open(context.config.package_cache_dir_or_default() / Path(deb).relative_to("/var/cache"), "rb") as i,
+ open(context.cache_dir / Path(deb).relative_to("/var"), "rb") as i,
tempfile.NamedTemporaryFile() as o
):
run(["dpkg-deb", "--fsys-tarfile", "/dev/stdin"], stdin=i, stdout=o, sandbox=context.sandbox())
# SPDX-License-Identifier: LGPL-2.1+
-import contextlib
import os
-from collections.abc import Iterator
from pathlib import Path
-from mkosi.config import Config, ConfigFeature
+from mkosi.config import ConfigFeature
from mkosi.context import Context
-from mkosi.log import complete_step
from mkosi.sandbox import apivfs_cmd, finalize_crypto_mounts
from mkosi.tree import rmtree
from mkosi.types import PathString
-from mkosi.user import INVOKING_USER
from mkosi.util import flatten
]
mounts += flatten(
- ["--bind", context.config.package_cache_dir_or_default() / d, Path("/var/cache") / d]
- for d in ("apt", dnf_subdir(context), "pacman/pkg", "zypp")
- if (context.config.package_cache_dir_or_default() / d).exists()
- )
-
- mounts += flatten(
- ["--bind", context.config.package_state_dir_or_default() / d, Path("/var/lib") / d]
- for d in ("apt", dnf_subdir(context))
- if (context.config.package_state_dir_or_default() / d).exists()
+ ["--bind", context.cache_dir / d, Path("/var") / d]
+ for d in (
+ "lib/apt",
+ "cache/apt",
+ f"cache/{dnf_subdir(context)}",
+ f"lib/{dnf_subdir(context)}",
+ "cache/pacman/pkg",
+ "cache/zypp",
+ )
+ if (context.cache_dir / d).exists()
)
return mounts
-
-
-@contextlib.contextmanager
-def rchown_package_manager_cache_dirs(config: Config) -> Iterator[None]:
- try:
- yield
- finally:
- if INVOKING_USER.is_regular_user():
- with complete_step("Fixing ownership of package manager cache directories"):
- for p in ("apt", "dnf", "libdnf5", "pacman", "zypp"):
- for d in (config.package_cache_dir_or_default(), config.package_state_dir_or_default()):
- INVOKING_USER.rchown(d / p)
from mkosi.run import find_binary, run
from mkosi.sandbox import apivfs_cmd
from mkosi.types import PathString
-from mkosi.user import INVOKING_USER
from mkosi.util import sort_packages, umask
(context.root / "var/lib/dpkg").mkdir(parents=True, exist_ok=True)
(context.root / "var/lib/dpkg/status").touch()
- INVOKING_USER.mkdir(context.config.package_cache_dir_or_default() / "apt")
- INVOKING_USER.mkdir(context.config.package_state_dir_or_default() / "apt")
+ (context.cache_dir / "lib/apt").mkdir(exist_ok=True, parents=True)
+ (context.cache_dir / "cache/apt").mkdir(exist_ok=True, parents=True)
# We have a special apt.conf outside of pkgmngr dir that only configures "Dir::Etc" that we pass to APT_CONFIG to
# tell apt it should read config files from /etc/apt in case this is overridden by distributions. This is required
from mkosi.run import find_binary, run
from mkosi.sandbox import apivfs_cmd
from mkosi.types import PathString
-from mkosi.user import INVOKING_USER
from mkosi.util import sort_packages
(context.pkgmngr / "etc/dnf/vars").mkdir(exist_ok=True, parents=True)
(context.pkgmngr / "etc/yum.repos.d").mkdir(exist_ok=True, parents=True)
- INVOKING_USER.mkdir(context.config.package_cache_dir_or_default() / dnf_subdir(context))
- INVOKING_USER.mkdir(context.config.package_state_dir_or_default() / dnf_subdir(context))
+ (context.cache_dir / "cache" / dnf_subdir(context)).mkdir(exist_ok=True, parents=True)
+ (context.cache_dir / "lib" / dnf_subdir(context)).mkdir(exist_ok=True, parents=True)
config = context.pkgmngr / "etc/dnf/dnf.conf"
from mkosi.run import run
from mkosi.sandbox import apivfs_cmd
from mkosi.types import PathString
-from mkosi.user import INVOKING_USER
from mkosi.util import sort_packages, umask
from mkosi.versioncomp import GenericVersion
with umask(~0o755):
(context.root / "var/lib/pacman").mkdir(exist_ok=True, parents=True)
- INVOKING_USER.mkdir(context.config.package_cache_dir_or_default() / "pacman/pkg")
+ (context.cache_dir / "cache/pacman/pkg").mkdir(parents=True, exist_ok=True)
config = context.pkgmngr / "etc/pacman.conf"
if config.exists():
from mkosi.run import run
from mkosi.sandbox import apivfs_cmd
from mkosi.types import PathString
-from mkosi.user import INVOKING_USER
from mkosi.util import sort_packages
config = context.pkgmngr / "etc/zypp/zypp.conf"
config.parent.mkdir(exist_ok=True, parents=True)
- INVOKING_USER.mkdir(context.config.package_cache_dir_or_default() / "zypp")
+ (context.cache_dir / "cache/zypp").mkdir(exist_ok=True, parents=True)
# rpm.install.excludedocs can only be configured in zypp.conf so we append
# to any user provided config file. Let's also bump the refresh delay to
`CacheDirectory=`, `--cache-dir=`
-: Takes a path to a directory to use as the incremental cache directory
- for the incremental images produced when the `Incremental=` option is
- enabled. If this option is not used, but a `mkosi.cache/` directory is
- found in the local directory it is automatically used for this
- purpose.
-
-`PackageCacheDirectory=`, `--package-cache-dir`
-
-: Takes a path to a directory to use as the package cache directory for
- the distribution package manager used. If unset, a suitable directory
- in the user's home directory or system is used.
+: Takes a path to a directory to use as package cache for the
+ distribution package manager used. If this option is not used, but a
+ `mkosi.cache/` directory is found in the local directory it is
+ automatically used for this purpose.
`BuildDirectory=`, `--build-dir=`
from pathlib import Path
from mkosi.log import die
-from mkosi.run import run, spawn
+from mkosi.run import spawn
from mkosi.util import flock
SUBRANGE = 65536
def home(cls) -> Path:
return Path(f"~{cls.name()}").expanduser()
- @classmethod
- def is_regular_user(cls) -> bool:
- return cls.uid >= 1000
-
- @classmethod
- def cache_dir(cls) -> Path:
- if (cache := os.getenv("XDG_CACHE_HOME") or (cache := os.getenv("CACHE_DIRECTORY"))):
- return Path(cache)
-
- if (cls.is_regular_user() and Path.cwd().is_relative_to(INVOKING_USER.home())):
- return INVOKING_USER.home() / ".cache"
-
- return Path("/var/cache")
-
- @classmethod
- def state_dir(cls) -> Path:
- if (state := os.getenv("XDG_STATE_HOME") or (state := os.getenv("STATE_DIRECTORY"))):
- return Path(state)
-
- if (cls.is_regular_user() and Path.cwd().is_relative_to(INVOKING_USER.home())):
- return INVOKING_USER.home() / ".local/state"
-
- return Path("/var/lib")
-
- @classmethod
- def mkdir(cls, path: Path) -> None:
- user = cls.uid if cls.is_regular_user() and path.is_relative_to(cls.home()) else os.getuid()
- group = cls.gid if cls.is_regular_user() and path.is_relative_to(cls.home()) else os.getgid()
- run(["mkdir", "--parents", path], user=user, group=group)
-
- @classmethod
- def rchown(cls, path: Path) -> None:
- if cls.is_regular_user() and path.is_relative_to(INVOKING_USER.home()) and path.exists():
- run(["chown", "--recursive", f"{INVOKING_USER.uid}:{INVOKING_USER.gid}", path])
-
def read_subrange(path: Path) -> int:
uid = str(os.getuid())
"Output": "outfile",
"OutputDirectory": "/your/output/here",
"Overlay": true,
- "PackageCacheDirectory": "/a/b/c",
"PackageDirectories": [],
"PackageManagerTrees": [
{
output_dir = Path("/your/output/here"),
output_format = OutputFormat.uki,
overlay = True,
- package_cache_dir = Path("/a/b/c"),
package_directories = [],
package_manager_trees = [ConfigTree(Path("/foo/bar"), None)],
packages = [],
projects / thirdparty / mkosi.git / commitdiff
