#!/usr/bin/env python3
|
|
#
|
# This file and its contents are supplied under the terms of the
|
# Common Development and Distribution License ("CDDL"), version 1.0.
|
# You may only use this file in accordance with the terms of version
|
# 1.0 of the CDDL.
|
#
|
# A full copy of the text of the CDDL should have accompanied this
|
# source. A copy of the CDDL is also available via the Internet at
|
# http://www.illumos.org/license/CDDL.
|
#
|
|
#
|
# Copyright 2020 Adam Stevko
|
#
|
|
#
|
# userland-zone - tool to manage userland template and build zone lifecycle
|
#
|
|
import argparse
|
import errno
|
import logging
|
import os
|
import pwd
|
import subprocess
|
|
logger = logging.getLogger("userland-zone")
|
|
BUILD_ZONE_NAME = "bz"
|
TEMPLATE_ZONE_NAME = "-".join([BUILD_ZONE_NAME, "template"])
|
ZONES_ROOT = "/zones"
|
ARCHIVES_DIR = "/ws/archives"
|
CODE_DIR = "/ws/code"
|
DEVELOPER_PACKAGES = ["build-essential"]
|
|
|
class Zone:
|
def __init__(
|
self, name, path=None, brand="nlipkg", user="oi", user_id=1000,
|
):
|
self._name = name
|
self._path = path or self._get_zone_path()
|
self._brand = brand
|
self._user = user
|
self._user_id = user_id
|
|
@property
|
def name(self):
|
return self._name
|
|
@property
|
def state(self):
|
output = self._zoneadm(["list", "-p"], stdout=subprocess.PIPE)
|
# -:name:installed:/zones/name:22dae542-e5ce-c86a-e5c7-e34d74b696bf:nlipkg:shared
|
return output.split(":")[2]
|
|
@property
|
def is_running(self):
|
return self.state == "running"
|
|
def _zonecfg(self, args, **kwargs):
|
zonecfg_args = ["-z", self._name]
|
zonecfg_args.extend(args)
|
return execute("zonecfg", zonecfg_args, **kwargs)
|
|
def _zoneadm(self, args, **kwargs):
|
zoneadm_args = ["-z", self._name]
|
zoneadm_args.extend(args)
|
return execute("zoneadm", zoneadm_args, **kwargs)
|
|
def _pkg(self, args, **kwargs):
|
return execute("pkg", args, **kwargs)
|
|
def _get_zone_path(self):
|
output = self._zoneadm(["list", "-p"], stdout=subprocess.PIPE, check=False)
|
# -:name:installed:/zones/name:22dae542-e5ce-c86a-e5c7-e34d74b696bf:nlipkg:shared
|
return output.split(":")[3]
|
|
def create(self, extra_args=None):
|
if not self._path:
|
raise ValueError("Zone path is required when creating the zone")
|
|
zonecfg_args = [
|
"create -b",
|
"set zonepath={path}".format(path=self._path),
|
"set zonename={name}".format(name=self._name),
|
"set brand={brand}".format(brand=self._brand),
|
]
|
|
if extra_args:
|
zonecfg_args.extend(extra_args)
|
zonecfg_args.append("commit")
|
|
zonecfg_args = [";".join(zonecfg_args)]
|
return self._zonecfg(zonecfg_args)
|
|
def delete(self):
|
return self._zonecfg(["delete", "-F"])
|
|
def install(self):
|
return self._zoneadm(["install", "-e"] + DEVELOPER_PACKAGES)
|
|
def uninstall(self):
|
return self._zoneadm(["uninstall", "-F"])
|
|
def halt(self):
|
return self._zoneadm(["halt"])
|
|
def boot(self):
|
return self._zoneadm(["boot"])
|
|
def clone(self, source_zone):
|
return self._zoneadm(["clone", source_zone.name])
|
|
def update(self):
|
zone_root_path = os.path.join(self._path, "root")
|
return self._pkg(["-R", zone_root_path, "update"])
|
|
def configure(self, sysding_lines=None):
|
sysding_config = [
|
"#!/usr/bin/ksh",
|
"setup_timezone UTC",
|
"setup_locale en_US.UTF-8",
|
'setup_user_account {user} {uid} {gid} "{gecos}" {home} {shell}'.format(
|
user=self._user,
|
uid=self._user_id,
|
gid="10",
|
gecos="Build user",
|
home="/export/home/{}".format(self._user),
|
shell="/usr/bin/bash",
|
),
|
"/usr/sbin/usermod -P'Primary Administrator' {user}".format(
|
user=self._user
|
),
|
]
|
|
if sysding_lines:
|
sysding_config.extend(sysding_lines)
|
sysding_config.append("\n")
|
|
sysding_conf = os.path.join(self._path, "root", "etc", "sysding.conf")
|
with open(sysding_conf, "w") as f:
|
f.write("\n".join(sysding_config))
|
|
|
def execute(cmd, args, **kwargs):
|
ret, result = None, None
|
|
if "check" not in kwargs:
|
kwargs["check"] = True
|
|
try:
|
logger.debug('Executing "%s"', " ".join([cmd] + args))
|
result = subprocess.run([cmd] + args, **kwargs)
|
except subprocess.CalledProcessError as e:
|
logger.error(
|
'Command "%s" exited with %s', " ".join([cmd] + args), e.returncode
|
)
|
except OSError as e:
|
if e.errno == errno.ENOENT:
|
raise ValueError("{} cannot be found".format(cmd))
|
|
if result and result.stdout:
|
ret = result.stdout.decode()
|
ret = ret.rstrip()
|
|
return ret
|
|
|
def parse_arguments():
|
def dir_path(path):
|
if os.path.exists(path) and os.path.isdir(path):
|
return path
|
raise argparse.ArgumentTypeError("{} is not a valid path".format(path))
|
|
parser = argparse.ArgumentParser()
|
parser.add_argument("--prefix", default=BUILD_ZONE_NAME, help="Zone name prefix")
|
subparsers = parser.add_subparsers(title="subcommands", dest="subcommand")
|
|
# create-template
|
ct_parser = subparsers.add_parser(
|
"create-template", help="Create template zone for userland builds"
|
)
|
ct_parser.add_argument(
|
"-p",
|
help="Zone path",
|
default=os.path.join(ZONES_ROOT, TEMPLATE_ZONE_NAME),
|
dest="zone_path",
|
)
|
ct_parser.add_argument(
|
"-u",
|
help="User ID to use for build user",
|
default=os.getuid(),
|
dest="uid",
|
)
|
ct_parser.add_argument(
|
"-l",
|
help="User name to use for build user",
|
default=pwd.getpwuid(os.getuid()).pw_name,
|
dest="user",
|
)
|
|
# update-template
|
_ = subparsers.add_parser(
|
"update-template", help="Update template zone for userland builds"
|
)
|
|
# destroy-template
|
_ = subparsers.add_parser(
|
"destroy-template", help="Destroy template zone for userland builds"
|
)
|
|
# spawn-zone
|
sz_parser = subparsers.add_parser(
|
"spawn-zone", help="Spawn build zone for userland builds"
|
)
|
sz_parser.add_argument(
|
"--id", required=True, help="Zone identifier that identifies build zone"
|
)
|
sz_parser.add_argument(
|
"--archive-dir",
|
default=ARCHIVES_DIR,
|
type=dir_path,
|
help="Path to userland archives",
|
)
|
sz_parser.add_argument(
|
"--code-dir",
|
default=CODE_DIR,
|
type=dir_path,
|
help="Path to userland code repository checkoutt",
|
)
|
|
# destroy-zone
|
dz_parser = subparsers.add_parser("destroy-zone", help="Destroy build zone")
|
dz_parser.add_argument(
|
"--id", required=True, help="Zone identifier that identifies build zone"
|
)
|
|
args = parser.parse_args()
|
|
if not args.subcommand:
|
parser.print_help()
|
exit(1)
|
|
return args
|
|
|
def create_template(zone_path, zone_name=TEMPLATE_ZONE_NAME, user='oi', user_id=1000):
|
zone = Zone(path=zone_path, name=zone_name, user=user, user_id=user_id)
|
zone.create()
|
zone.install()
|
zone.configure()
|
|
|
def destroy_zone(zone_name=TEMPLATE_ZONE_NAME):
|
zone = Zone(path=os.path.join(ZONES_ROOT, zone_name), name=zone_name)
|
|
if zone.is_running:
|
zone.halt()
|
zone.uninstall()
|
zone.delete()
|
|
|
def spawn_zone(id, prefix=BUILD_ZONE_NAME, archive_dir=ARCHIVES_DIR, code_dir=CODE_DIR):
|
name = "{}-{}".format(prefix, id)
|
zone = Zone(name=name, path=os.path.join(ZONES_ROOT, name))
|
|
template_zone = Zone(name=TEMPLATE_ZONE_NAME)
|
|
# To avoid zonecfg failure, we will check for existence of archive_dir and code_dir
|
if not os.path.exists(archive_dir):
|
raise ValueError(
|
"Userland archives dir {} has to exist in the global zone before we can clone the build zone!"
|
)
|
|
if not os.path.exists(code_dir):
|
raise ValueError(
|
"Userland archives dir {} has to exist in the global zone before we can clone the build zone!"
|
)
|
|
extra_args = [
|
"add fs",
|
"set dir = {}".format(ARCHIVES_DIR),
|
"set special = {}".format(archive_dir),
|
"set type = lofs",
|
"add options [rw,nodevices]",
|
"end",
|
"add fs",
|
"set dir = {}".format(CODE_DIR),
|
"set special = {}".format(code_dir),
|
"set type = lofs",
|
"add options [rw,nodevices]",
|
"end",
|
]
|
zone.create(extra_args=extra_args)
|
zone.clone(template_zone)
|
zone.boot()
|
|
|
def update_template(zone_name=TEMPLATE_ZONE_NAME):
|
zone = Zone(name=zone_name)
|
zone.update()
|
|
|
def main():
|
args = parse_arguments()
|
|
if args.subcommand == "create-template":
|
zone_name = '{}-{}'.format(args.prefix, 'template')
|
create_template(zone_path=args.zone_path, zone_name=zone_name, user=args.user, user_id=args.uid)
|
elif args.subcommand == "destroy-template":
|
zone_name = '{}-{}'.format(args.prefix, 'template')
|
destroy_zone(zone_name=zone_name)
|
elif args.subcommand == "update-template":
|
zone_name = '{}-{}'.format(args.prefix, 'template')
|
update_template(zone_name=zone_name)
|
elif args.subcommand == "spawn-zone":
|
spawn_zone(id=args.id, prefix=args.prefix, archive_dir=args.archive_dir, code_dir=args.code_dir)
|
elif args.subcommand == "destroy-zone":
|
zone_name = "{}-{}".format(args.prefix, args.id)
|
destroy_zone(zone_name=zone_name)
|
|
|
if __name__ == "__main__":
|
main()
|
