saltstack/salt
1
0
Fork 0
mirror of https://github.com/saltstack/salt.git synced 2025-04-17 10:10:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Fixed committed reviewer suggestion

Browse source
This commit is contained in:
David Murphy 2023-06-07 15:17:46 -06:00 • committed by Megan Wilhite
parent d572d1a703
commit 7916ffb63e
5 changed files with 202 additions and 232 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

276
salt/modules/lxc.py
View file

@ -119,7 +119,7 @@ def version():
ver = Version(cversion["stdout"])
if ver < Version("1.0"):
raise CommandExecutionError("LXC should be at least 1.0")
__context__[k] = "{}".format(ver)
__context__[k] = f"{ver}"
return __context__.get(k, None)
@ -141,7 +141,7 @@ def _ip_sort(ip):
idx = "201"
elif "::" in ip:
idx = "100"
return "{}___{}".format(idx, ip)
return f"{idx}___{ip}"
def search_lxc_bridges():
@ -173,7 +173,7 @@ def search_lxc_bridges():
for ifc, ip in __grains__.get("ip_interfaces", {}).items():
if ifc in running_bridges:
bridges.add(ifc)
elif os.path.exists("/sys/devices/virtual/net/{}/bridge".format(ifc)):
elif os.path.exists(f"/sys/devices/virtual/net/{ifc}/bridge"):
bridges.add(ifc)
bridges = list(bridges)
# if we found interfaces that have lxc in their names
@ -186,7 +186,7 @@ def search_lxc_bridges():
pref = "a"
elif "br0" == a:
pref = "c"
return "{}_{}".format(pref, a)
return f"{pref}_{a}"
bridges.sort(key=sort_bridges)
__context__["lxc.bridges"] = bridges
@ -439,12 +439,12 @@ def cloud_init_interface(name, vm_=None, **kwargs):
if ip:
fullip = ip
if netmask:
fullip += "/{}".format(netmask)
fullip += f"/{netmask}"
eth0["ipv4"] = fullip
if mac is not None:
eth0["mac"] = mac
for ix, iopts in enumerate(_cloud_get("additional_ips", [])):
ifh = "eth{}".format(ix + 1)
ifh = f"eth{ix + 1}"
ethx = nic_opts.setdefault(ifh, {})
if gw is None:
gw = iopts.get("gateway", ethx.get("gateway", None))
@ -465,7 +465,7 @@ def cloud_init_interface(name, vm_=None, **kwargs):
ethx["ipv4"] = aip
nm = iopts.get("netmask", "")
if nm:
ethx["ipv4"] += "/{}".format(nm)
ethx["ipv4"] += f"/{nm}"
for i in ("mac", "hwaddr"):
if i in iopts:
ethx["mac"] = iopts[i]
@ -543,7 +543,7 @@ def _get_profile(key, name, **kwargs):
profile_match = {}
else:
profile_match = __salt__["config.get"](
"lxc.{1}:{0}".format(name, key), default=None, merge="recurse"
f"lxc.{key}:{name}", default=None, merge="recurse"
)
if profile_match is None:
# No matching profile, make the profile an empty dict so that
@ -551,7 +551,7 @@ def _get_profile(key, name, **kwargs):
profile_match = {}
if not isinstance(profile_match, dict):
raise CommandExecutionError("lxc.{} must be a dictionary".format(key))
raise CommandExecutionError(f"lxc.{key} must be a dictionary")
# Overlay the kwargs to override matched profile data
overrides = salt.utils.args.clean_kwargs(**copy.deepcopy(kwargs))
@ -669,7 +669,7 @@ def _rand_cpu_str(cpu):
cpu = int(cpu)
avail = __salt__["status.nproc"]()
if cpu < avail:
return "0-{}".format(avail)
return f"0-{avail}"
to_set = set()
while len(to_set) < cpu:
choice = random.randint(0, avail - 1)
@ -832,7 +832,7 @@ def _network_conf(conf_tuples=None, **kwargs):
"ipv6",
]:
continue
ret.append({"lxc.network.{}".format(key): val})
ret.append({f"lxc.network.{key}": val})
# gateway (in automode) must be appended following network conf !
if not gateway:
gateway = args.get("gateway", None)
@ -892,7 +892,7 @@ def _get_lxc_default_data(**kwargs):
for k in ["utsname", "rootfs"]:
val = kwargs.get(k, None)
if val is not None:
ret["lxc.{}".format(k)] = val
ret[f"lxc.{k}"] = val
autostart = kwargs.get("autostart")
# autostart can have made in kwargs, but with the None
# value which is invalid, we need an explicit boolean
@ -1115,7 +1115,7 @@ def _get_base(**kwargs):
hash_ = salt.utils.hashutils.get_hash(
img_tar, __salt__["config.get"]("hash_type")
)
name = "__base_{}_{}_{}".format(proto, img_name, hash_)
name = f"__base_{proto}_{img_name}_{hash_}"
if not exists(name, path=path):
create(
name, template=template, image=image, path=path, vgname=vgname, **kwargs
@ -1125,11 +1125,11 @@ def _get_base(**kwargs):
edit_conf(
info(name, path=path)["config"],
out_format="commented",
**{"lxc.rootfs": rootfs}
**{"lxc.rootfs": rootfs},
)
return name
elif template:
name = "__base_{}".format(template)
name = f"__base_{template}"
if not exists(name, path=path):
create(
name, template=template, image=image, path=path, vgname=vgname, **kwargs
@ -1139,7 +1139,7 @@ def _get_base(**kwargs):
edit_conf(
info(name, path=path)["config"],
out_format="commented",
**{"lxc.rootfs": rootfs}
**{"lxc.rootfs": rootfs},
)
return name
return ""
@ -1171,7 +1171,7 @@ def init(
bootstrap_args=None,
bootstrap_shell=None,
bootstrap_url=None,
**kwargs
**kwargs,
):
"""
Initialize a new container.
@ -1499,7 +1499,7 @@ def init(
try:
stop(name, path=path)
except (SaltInvocationError, CommandExecutionError) as exc:
ret["comment"] = "Unable to stop container: {}".format(exc)
ret["comment"] = f"Unable to stop container: {exc}"
if changes:
ret["changes"] = changes_dict
return ret
@ -1507,7 +1507,7 @@ def init(
try:
start(name, path=path)
except (SaltInvocationError, CommandExecutionError) as exc:
ret["comment"] = "Unable to stop container: {}".format(exc)
ret["comment"] = f"Unable to stop container: {exc}"
if changes:
ret["changes"] = changes_dict
return ret
@ -1515,7 +1515,7 @@ def init(
if remove_seed_marker:
run(
name,
"rm -f '{}'".format(SEED_MARKER),
f"rm -f '{SEED_MARKER}'",
path=path,
chroot_fallback=False,
python_shell=False,
@ -1524,11 +1524,11 @@ def init(
# set the default user/password, only the first time
if ret.get("result", True) and password:
gid = "/.lxc.initial_pass"
gids = [gid, "/lxc.initial_pass", "/.lxc.{}.initial_pass".format(name)]
gids = [gid, "/lxc.initial_pass", f"/.lxc.{name}.initial_pass"]
if not any(
retcode(
name,
'test -e "{}"'.format(x),
f'test -e "{x}"',
chroot_fallback=True,
path=path,
ignore_retcode=True,
@ -1544,7 +1544,7 @@ def init(
default_user not in users
and retcode(
name,
"id {}".format(default_user),
f"id {default_user}",
python_shell=False,
path=path,
chroot_fallback=True,
@ -1563,7 +1563,7 @@ def init(
encrypted=password_encrypted,
)
except (SaltInvocationError, CommandExecutionError) as exc:
msg = "{}: Failed to set password".format(user) + exc.strerror
msg = f"{user}: Failed to set password" + exc.strerror
# only hardfail in unrecoverable situation:
# root cannot be setted up
if user == "root":
@ -1591,11 +1591,11 @@ def init(
if ret.get("result", True) and dnsservers:
# retro compatibility, test also old markers
gid = "/.lxc.initial_dns"
gids = [gid, "/lxc.initial_dns", "/lxc.{}.initial_dns".format(name)]
gids = [gid, "/lxc.initial_dns", f"/lxc.{name}.initial_dns"]
if not any(
retcode(
name,
'test -e "{}"'.format(x),
f'test -e "{x}"',
chroot_fallback=True,
path=path,
ignore_retcode=True,
@ -1628,13 +1628,13 @@ def init(
# retro compatibility, test also old markers
if remove_seed_marker:
run(name, "rm -f '{}'".format(SEED_MARKER), path=path, python_shell=False)
run(name, f"rm -f '{SEED_MARKER}'", path=path, python_shell=False)
gid = "/.lxc.initial_seed"
gids = [gid, "/lxc.initial_seed"]
if any(
retcode(
name,
"test -e {}".format(x),
f"test -e {x}",
path=path,
chroot_fallback=True,
ignore_retcode=True,
@ -1703,7 +1703,7 @@ def init(
try:
stop(name, path=path)
except (SaltInvocationError, CommandExecutionError) as exc:
ret["comment"] = "Unable to stop container: {}".format(exc)
ret["comment"] = f"Unable to stop container: {exc}"
ret["result"] = False
state_post = state(name, path=path)
@ -1711,7 +1711,7 @@ def init(
changes.append({"state": {"old": state_pre, "new": state_post}})
if ret.get("result", True):
ret["comment"] = "Container '{}' successfully initialized".format(name)
ret["comment"] = f"Container '{name}' successfully initialized"
ret["result"] = True
if changes:
ret["changes"] = changes_dict
@ -1834,8 +1834,8 @@ def _after_ignition_network_profile(cmd, ret, name, network_profile, path, nic_o
# destroy the container if it was partially created
cmd = "lxc-destroy"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += " -n {}".format(name)
cmd += f" -P {pipes.quote(path)}"
cmd += f" -n {name}"
__salt__["cmd.retcode"](cmd, python_shell=False)
raise CommandExecutionError(
"Container could not be created with cmd '{}': {}".format(
@ -1943,7 +1943,7 @@ def create(
# Required params for 'download' template
download_template_deps = ("dist", "release", "arch")
cmd = "lxc-create -n {}".format(name)
cmd = f"lxc-create -n {name}"
profile = get_container_profile(copy.deepcopy(profile))
kw_overrides = copy.deepcopy(kwargs)
@ -1959,7 +1959,7 @@ def create(
path = select("path")
if exists(name, path=path):
raise CommandExecutionError("Container '{}' already exists".format(name))
raise CommandExecutionError(f"Container '{name}' already exists")
tvg = select("vgname")
vgname = tvg if tvg else __salt__["config.get"]("lxc.vgname")
@ -1997,31 +1997,31 @@ def create(
)
options["imgtar"] = img_tar
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += f" -P {pipes.quote(path)}"
if not os.path.exists(path):
os.makedirs(path)
if config:
cmd += " -f {}".format(config)
cmd += f" -f {config}"
if template:
cmd += " -t {}".format(template)
cmd += f" -t {template}"
if backing:
backing = backing.lower()
cmd += " -B {}".format(backing)
cmd += f" -B {backing}"
if backing in ("zfs",):
if zfsroot:
cmd += " --zfsroot {}".format(zfsroot)
cmd += f" --zfsroot {zfsroot}"
if backing in ("lvm",):
if lvname:
cmd += " --lvname {}".format(lvname)
cmd += f" --lvname {lvname}"
if vgname:
cmd += " --vgname {}".format(vgname)
cmd += f" --vgname {vgname}"
if thinpool:
cmd += " --thinpool {}".format(thinpool)
cmd += f" --thinpool {thinpool}"
if backing not in ("dir", "overlayfs"):
if fstype:
cmd += " --fstype {}".format(fstype)
cmd += f" --fstype {fstype}"
if size:
cmd += " --fssize {}".format(size)
cmd += f" --fssize {size}"
if options:
if template == "download":
@ -2034,7 +2034,7 @@ def create(
)
cmd += " --"
for key, val in options.items():
cmd += " --{} {}".format(key, val)
cmd += f" --{key} {val}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
# please do not merge extra conflicting stuff
@ -2108,13 +2108,11 @@ def clone(name, orig, profile=None, network_profile=None, nic_opts=None, **kwarg
path = select("path")
if exists(name, path=path):
raise CommandExecutionError("Container '{}' already exists".format(name))
raise CommandExecutionError(f"Container '{name}' already exists")
_ensure_exists(orig, path=path)
if state(orig, path=path) != "stopped":
raise CommandExecutionError(
"Container '{}' must be stopped to be cloned".format(orig)
)
raise CommandExecutionError(f"Container '{orig}' must be stopped to be cloned")
backing = select("backing")
snapshot = select("snapshot")
@ -2132,21 +2130,21 @@ def clone(name, orig, profile=None, network_profile=None, nic_opts=None, **kwarg
if Version(version()) >= Version("2.0"):
# https://linuxcontainers.org/lxc/manpages//man1/lxc-copy.1.html
cmd = "lxc-copy"
cmd += " {} -n {} -N {}".format(snapshot, orig, name)
cmd += f" {snapshot} -n {orig} -N {name}"
else:
# https://linuxcontainers.org/lxc/manpages//man1/lxc-clone.1.html
cmd = "lxc-clone"
cmd += " {} -o {} -n {}".format(snapshot, orig, name)
cmd += f" {snapshot} -o {orig} -n {name}"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += f" -P {pipes.quote(path)}"
if not os.path.exists(path):
os.makedirs(path)
if backing:
backing = backing.lower()
cmd += " -B {}".format(backing)
cmd += f" -B {backing}"
if backing not in ("dir", "overlayfs"):
if size:
cmd += " -L {}".format(size)
cmd += f" -L {size}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
# please do not merge extra conflicting stuff
# inside those two line (ret =, return)
@ -2177,7 +2175,7 @@ def ls_(active=None, cache=True, path=None):
salt '*' lxc.ls
salt '*' lxc.ls active=True
"""
contextvar = "lxc.ls{}".format(path)
contextvar = f"lxc.ls{path}"
if active:
contextvar += ".active"
if cache and (contextvar in __context__):
@ -2186,7 +2184,7 @@ def ls_(active=None, cache=True, path=None):
ret = []
cmd = "lxc-ls"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += f" -P {pipes.quote(path)}"
if active:
cmd += " --active"
output = __salt__["cmd.run_stdout"](cmd, python_shell=False)
@ -2242,8 +2240,8 @@ def list_(extra=False, limit=None, path=None):
for container in ctnrs:
cmd = "lxc-info"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += " -n {}".format(container)
cmd += f" -P {pipes.quote(path)}"
cmd += f" -n {container}"
c_info = __salt__["cmd.run"](cmd, python_shell=False, output_loglevel="debug")
c_state = None
for line in c_info.splitlines():
@ -2294,20 +2292,20 @@ def _change_state(
return {
"result": True,
"state": {"old": expected, "new": expected},
"comment": "Container '{}' already {}".format(name, expected),
"comment": f"Container '{name}' already {expected}",
}
if cmd == "lxc-destroy":
# Kill the container first
scmd = "lxc-stop"
if path:
scmd += " -P {}".format(pipes.quote(path))
scmd += " -k -n {}".format(name)
scmd += f" -P {pipes.quote(path)}"
scmd += f" -k -n {name}"
__salt__["cmd.run"](scmd, python_shell=False)
if path and " -P " not in cmd:
cmd += " -P {}".format(pipes.quote(path))
cmd += " -n {}".format(name)
cmd += f" -P {pipes.quote(path)}"
cmd += f" -n {name}"
# certain lxc commands need to be taken with care (lxc-start)
# as te command itself mess with double forks; we must not
@ -2337,8 +2335,8 @@ def _change_state(
# some commands do not wait, so we will
rcmd = "lxc-wait"
if path:
rcmd += " -P {}".format(pipes.quote(path))
rcmd += " -n {} -s {}".format(name, expected.upper())
rcmd += f" -P {pipes.quote(path)}"
rcmd += f" -n {name} -s {expected.upper()}"
__salt__["cmd.run"](rcmd, python_shell=False, timeout=30)
_clear_context()
post = state(name, path=path)
@ -2351,7 +2349,7 @@ def _ensure_exists(name, path=None):
Raise an exception if the container does not exist
"""
if not exists(name, path=path):
raise CommandExecutionError("Container '{}' does not exist".format(name))
raise CommandExecutionError(f"Container '{name}' does not exist")
def _ensure_running(name, no_start=False, path=None):
@ -2373,11 +2371,11 @@ def _ensure_running(name, no_start=False, path=None):
return start(name, path=path)
elif pre == "stopped":
if no_start:
raise CommandExecutionError("Container '{}' is not running".format(name))
raise CommandExecutionError(f"Container '{name}' is not running")
return start(name, path=path)
elif pre == "frozen":
if no_start:
raise CommandExecutionError("Container '{}' is not running".format(name))
raise CommandExecutionError(f"Container '{name}' is not running")
return unfreeze(name, path=path)
@ -2459,13 +2457,11 @@ def start(name, **kwargs):
lxc_config = os.path.join(cpath, name, "config")
# we try to start, even without config, if global opts are there
if os.path.exists(lxc_config):
cmd += " -f {}".format(pipes.quote(lxc_config))
cmd += f" -f {pipes.quote(lxc_config)}"
cmd += " -d"
_ensure_exists(name, path=path)
if state(name, path=path) == "frozen":
raise CommandExecutionError(
"Container '{}' is frozen, use lxc.unfreeze".format(name)
)
raise CommandExecutionError(f"Container '{name}' is frozen, use lxc.unfreeze")
# lxc-start daemonize itself violently, we must not communicate with it
use_vt = kwargs.get("use_vt", None)
with_communicate = kwargs.get("with_communicate", False)
@ -2560,11 +2556,11 @@ def freeze(name, **kwargs):
start_ = kwargs.get("start", False)
if orig_state == "stopped":
if not start_:
raise CommandExecutionError("Container '{}' is stopped".format(name))
raise CommandExecutionError(f"Container '{name}' is stopped")
start(name, path=path)
cmd = "lxc-freeze"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += f" -P {pipes.quote(path)}"
ret = _change_state(cmd, name, "frozen", use_vt=use_vt, path=path)
if orig_state == "stopped" and start_:
ret["state"]["old"] = orig_state
@ -2596,10 +2592,10 @@ def unfreeze(name, path=None, use_vt=None):
"""
_ensure_exists(name, path=path)
if state(name, path=path) == "stopped":
raise CommandExecutionError("Container '{}' is stopped".format(name))
raise CommandExecutionError(f"Container '{name}' is stopped")
cmd = "lxc-unfreeze"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += f" -P {pipes.quote(path)}"
return _change_state(cmd, name, "running", path=path, use_vt=use_vt)
@ -2635,7 +2631,7 @@ def destroy(name, stop=False, path=None):
"""
_ensure_exists(name, path=path)
if not stop and state(name, path=path) != "stopped":
raise CommandExecutionError("Container '{}' is not stopped".format(name))
raise CommandExecutionError(f"Container '{name}' is not stopped")
return _change_state("lxc-destroy", name, None, path=path)
@ -2684,7 +2680,7 @@ def state(name, path=None):
"""
# Don't use _ensure_exists() here, it will mess with _change_state()
cachekey = "lxc.state.{}{}".format(name, path)
cachekey = f"lxc.state.{name}{path}"
try:
return __context__[cachekey]
except KeyError:
@ -2693,13 +2689,13 @@ def state(name, path=None):
else:
cmd = "lxc-info"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += " -n {}".format(name)
cmd += f" -P {pipes.quote(path)}"
cmd += f" -n {name}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
_clear_context()
raise CommandExecutionError(
"Unable to get state of container '{}'".format(name)
f"Unable to get state of container '{name}'"
)
c_infos = ret["stdout"].splitlines()
c_state = None
@ -2731,13 +2727,11 @@ def get_parameter(name, parameter, path=None):
_ensure_exists(name, path=path)
cmd = "lxc-cgroup"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += " -n {} {}".format(name, parameter)
cmd += f" -P {pipes.quote(path)}"
cmd += f" -n {name} {parameter}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
raise CommandExecutionError(
"Unable to retrieve value for '{}'".format(parameter)
)
raise CommandExecutionError(f"Unable to retrieve value for '{parameter}'")
return ret["stdout"].strip()
@ -2762,8 +2756,8 @@ def set_parameter(name, parameter, value, path=None):
cmd = "lxc-cgroup"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += " -n {} {} {}".format(name, parameter, value)
cmd += f" -P {pipes.quote(path)}"
cmd += f" -n {name} {parameter} {value}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
return False
@ -2787,7 +2781,7 @@ def info(name, path=None):
salt '*' lxc.info name
"""
cachekey = "lxc.info.{}{}".format(name, path)
cachekey = f"lxc.info.{name}{path}"
try:
return __context__[cachekey]
except KeyError:
@ -2799,9 +2793,7 @@ def info(name, path=None):
conf_file = os.path.join(cpath, str(name), "config")
if not os.path.isfile(conf_file):
raise CommandExecutionError(
"LXC config file {} does not exist".format(conf_file)
)
raise CommandExecutionError(f"LXC config file {conf_file} does not exist")
ret = {}
config = []
@ -3000,9 +2992,7 @@ def update_lxc_conf(name, lxc_conf, lxc_conf_unset, path=None):
cpath = get_root_path(path)
lxc_conf_p = os.path.join(cpath, name, "config")
if not os.path.exists(lxc_conf_p):
raise SaltInvocationError(
"Configuration file {} does not exist".format(lxc_conf_p)
)
raise SaltInvocationError(f"Configuration file {lxc_conf_p} does not exist")
changes = {"edited": [], "added": [], "removed": []}
ret = {"changes": changes, "result": True, "comment": ""}
@ -3054,17 +3044,15 @@ def update_lxc_conf(name, lxc_conf, lxc_conf_unset, path=None):
conf = ""
for key, val in dest_lxc_conf:
if not val:
conf += "{}\n".format(key)
conf += f"{key}\n"
else:
conf += "{} = {}\n".format(key.strip(), val.strip())
conf += f"{key.strip()} = {val.strip()}\n"
conf_changed = conf != orig_config
chrono = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
if conf_changed:
# DO NOT USE salt.utils.files.fopen here, i got (kiorky)
# problems with lxc configs which were wiped !
with salt.utils.files.fopen(
"{}.{}".format(lxc_conf_p, chrono), "w"
) as wfic:
with salt.utils.files.fopen(f"{lxc_conf_p}.{chrono}", "w") as wfic:
wfic.write(salt.utils.stringutils.to_str(conf))
with salt.utils.files.fopen(lxc_conf_p, "w") as wfic:
wfic.write(salt.utils.stringutils.to_str(conf))
@ -3113,8 +3101,8 @@ def set_dns(name, dnsservers=None, searchdomains=None, path=None):
searchdomains = searchdomains.split(",")
except AttributeError:
raise SaltInvocationError("Invalid input for 'searchdomains' parameter")
dns = ["nameserver {}".format(x) for x in dnsservers]
dns.extend(["search {}".format(x) for x in searchdomains])
dns = [f"nameserver {x}" for x in dnsservers]
dns.extend([f"search {x}" for x in searchdomains])
dns = "\n".join(dns) + "\n"
# we may be using resolvconf in the container
# We need to handle that case with care:
@ -3129,7 +3117,7 @@ def set_dns(name, dnsservers=None, searchdomains=None, path=None):
# - We finally also set /etc/resolv.conf in all cases
rstr = __salt__["test.random_hash"]()
# no tmp here, apparmor won't let us execute !
script = "/sbin/{}_dns.sh".format(rstr)
script = f"/sbin/{rstr}_dns.sh"
DNS_SCRIPT = "\n".join(
[
# 'set -x',
@ -3153,7 +3141,7 @@ def set_dns(name, dnsservers=None, searchdomains=None, path=None):
]
)
result = run_all(
name, "tee {}".format(script), path=path, stdin=DNS_SCRIPT, python_shell=True
name, f"tee {script}", path=path, stdin=DNS_SCRIPT, python_shell=True
)
if result["retcode"] == 0:
result = run_all(
@ -3170,7 +3158,7 @@ def set_dns(name, dnsservers=None, searchdomains=None, path=None):
python_shell=True,
)
if result["retcode"] != 0:
error = "Unable to write to /etc/resolv.conf in container '{}'".format(name)
error = f"Unable to write to /etc/resolv.conf in container '{name}'"
if result["stderr"]:
error += ": {}".format(result["stderr"])
raise CommandExecutionError(error)
@ -3193,12 +3181,12 @@ def running_systemd(name, cache=True, path=None):
salt '*' lxc.running_systemd ubuntu
"""
k = "lxc.systemd.test.{}{}".format(name, path)
k = f"lxc.systemd.test.{name}{path}"
ret = __context__.get(k, None)
if ret is None or not cache:
rstr = __salt__["test.random_hash"]()
# no tmp here, apparmor won't let us execute !
script = "/sbin/{}_testsystemd.sh".format(rstr)
script = f"/sbin/{rstr}_testsystemd.sh"
# ubuntu already had since trusty some bits of systemd but was
# still using upstart ...
# we need to be a bit more careful that just testing that systemd
@ -3227,7 +3215,7 @@ def running_systemd(name, cache=True, path=None):
"""
)
result = run_all(
name, "tee {}".format(script), path=path, stdin=_script, python_shell=True
name, f"tee {script}", path=path, stdin=_script, python_shell=True
)
if result["retcode"] == 0:
result = run_all(
@ -3237,9 +3225,7 @@ def running_systemd(name, cache=True, path=None):
python_shell=True,
)
else:
raise CommandExecutionError(
"lxc {} failed to copy initd tester".format(name)
)
raise CommandExecutionError(f"lxc {name} failed to copy initd tester")
run_all(
name,
'sh -c \'if [ -f "{0}" ];then rm -f "{0}";fi\''.format(script),
@ -3361,9 +3347,9 @@ def wait_started(name, path=None, timeout=300):
"""
if not exists(name, path=path):
raise CommandExecutionError("Container {} does does exists".format(name))
raise CommandExecutionError(f"Container {name} does does exists")
if not state(name, path=path) == "running":
raise CommandExecutionError("Container {} is not running".format(name))
raise CommandExecutionError(f"Container {name} is not running")
ret = False
if running_systemd(name, path=path):
test_started = test_sd_started_state
@ -3520,7 +3506,7 @@ def bootstrap(
seeded = (
retcode(
name,
"test -e '{}'".format(SEED_MARKER),
f"test -e '{SEED_MARKER}'",
path=path,
chroot_fallback=True,
ignore_retcode=True,
@ -3543,9 +3529,9 @@ def bootstrap(
if needs_install or force_install or unconditional_install:
if install:
rstr = __salt__["test.random_hash"]()
configdir = "/var/tmp/.c_{}".format(rstr)
configdir = f"/var/tmp/.c_{rstr}"
cmd = "install -m 0700 -d {}".format(configdir)
cmd = f"install -m 0700 -d {configdir}"
if run_all(name, cmd, path=path, python_shell=False)["retcode"] != 0:
log.error("tmpdir %s creation failed %s", configdir, cmd)
return False
@ -3553,11 +3539,11 @@ def bootstrap(
bs_ = __salt__["config.gather_bootstrap_script"](
bootstrap=bootstrap_url
)
script = "/sbin/{}_bootstrap.sh".format(rstr)
script = f"/sbin/{rstr}_bootstrap.sh"
copy_to(name, bs_, script, path=path)
result = run_all(
name,
'sh -c "chmod +x {}"'.format(script),
f'sh -c "chmod +x {script}"',
path=path,
python_shell=True,
)
@ -3631,7 +3617,7 @@ def bootstrap(
freeze(name, path=path)
# mark seeded upon successful install
if ret:
run(name, "touch '{}'".format(SEED_MARKER), path=path, python_shell=False)
run(name, f"touch '{SEED_MARKER}'", path=path, python_shell=False)
return ret
@ -3652,7 +3638,7 @@ def attachable(name, path=None):
salt 'minion' lxc.attachable ubuntu
"""
cachekey = "lxc.attachable{}{}".format(name, path)
cachekey = f"lxc.attachable{name}{path}"
try:
return __context__[cachekey]
except KeyError:
@ -3662,8 +3648,8 @@ def attachable(name, path=None):
log.debug("Checking if LXC container %s is attachable", name)
cmd = "lxc-attach"
if path:
cmd += " -P {}".format(pipes.quote(path))
cmd += " --clear-env -n {} -- /usr/bin/env".format(name)
cmd += f" -P {pipes.quote(path)}"
cmd += f" --clear-env -n {name} -- /usr/bin/env"
result = (
__salt__["cmd.retcode"](
cmd, python_shell=False, output_loglevel="quiet", ignore_retcode=True
@ -3719,7 +3705,7 @@ def _run(
)
else:
if not chroot_fallback:
raise CommandExecutionError("{} is not attachable.".format(name))
raise CommandExecutionError(f"{name} is not attachable.")
rootfs = info(name, path=path).get("rootfs")
# Set context var to make cmd.run_chroot run cmd.run instead of
# cmd.run_all.
@ -4214,7 +4200,7 @@ def _get_md5(name, path):
Get the MD5 checksum of a file from a container
"""
output = run_stdout(
name, 'md5sum "{}"'.format(path), chroot_fallback=True, ignore_retcode=True
name, f'md5sum "{path}"', chroot_fallback=True, ignore_retcode=True
)
try:
return output.split()[0]
@ -4381,7 +4367,7 @@ def write_conf(conf_file, conf):
line[key],
(str, (str,), (int,), float),
):
out_line = " = ".join((key, "{}".format(line[key])))
out_line = " = ".join((key, f"{line[key]}"))
elif isinstance(line[key], dict):
out_line = " = ".join((key, line[key]["value"]))
if "comment" in line[key]:
@ -4474,7 +4460,7 @@ def edit_conf(
net_changes = _config_list(
conf,
only_net=True,
**{"network_profile": DEFAULT_NIC, "nic_opts": nic_opts}
**{"network_profile": DEFAULT_NIC, "nic_opts": nic_opts},
)
if net_changes:
lxc_config.extend(net_changes)
@ -4524,20 +4510,20 @@ def reboot(name, path=None):
salt 'minion' lxc.reboot myvm
"""
ret = {"result": True, "changes": {}, "comment": "{} rebooted".format(name)}
ret = {"result": True, "changes": {}, "comment": f"{name} rebooted"}
does_exist = exists(name, path=path)
if does_exist and (state(name, path=path) == "running"):
try:
stop(name, path=path)
except (SaltInvocationError, CommandExecutionError) as exc:
ret["comment"] = "Unable to stop container: {}".format(exc)
ret["comment"] = f"Unable to stop container: {exc}"
ret["result"] = False
return ret
if does_exist and (state(name, path=path) != "running"):
try:
start(name, path=path)
except (SaltInvocationError, CommandExecutionError) as exc:
ret["comment"] = "Unable to stop container: {}".format(exc)
ret["comment"] = f"Unable to stop container: {exc}"
ret["result"] = False
return ret
ret["changes"][name] = "rebooted"
@ -4559,7 +4545,7 @@ def reconfigure(
utsname=None,
rootfs=None,
path=None,
**kwargs
**kwargs,
):
"""
Reconfigure a container.
@ -4625,7 +4611,7 @@ def reconfigure(
path = os.path.join(cpath, name, "config")
ret = {
"name": name,
"comment": "config for {} up to date".format(name),
"comment": f"config for {name} up to date",
"result": True,
"changes": changes,
}
@ -4677,7 +4663,7 @@ def reconfigure(
edit_conf(path, out_format="commented", lxc_config=new_cfg)
chunks = read_conf(path, out_format="commented")
if old_chunks != chunks:
ret["comment"] = "{} lxc config updated".format(name)
ret["comment"] = f"{name} lxc config updated"
if state(name, path=path) == "running":
cret = reboot(name, path=path)
ret["result"] = cret["result"]
@ -4763,9 +4749,9 @@ def get_pid(name, path=None):
"""
if name not in list_(limit="running", path=path):
raise CommandExecutionError(
"Container {} is not running, can't determine PID".format(name)
f"Container {name} is not running, can't determine PID"
)
info = __salt__["cmd.run"]("lxc-info -n {}".format(name)).split("\n")
info = __salt__["cmd.run"](f"lxc-info -n {name}").split("\n")
pid = [
line.split(":")[1].strip()
for line in info
@ -4812,21 +4798,19 @@ def add_veth(name, interface_name, bridge=None, path=None):
raise CommandExecutionError(
"Directory /var/run required for lxc.add_veth doesn't exists"
)
if not __salt__["file.file_exists"]("/proc/{}/ns/net".format(pid)):
if not __salt__["file.file_exists"](f"/proc/{pid}/ns/net"):
raise CommandExecutionError(
"Proc file for container {} network namespace doesn't exists".format(name)
f"Proc file for container {name} network namespace doesn't exists"
)
if not __salt__["file.directory_exists"]("/var/run/netns"):
__salt__["file.mkdir"]("/var/run/netns")
# Ensure that the symlink is up to date (change on container restart)
if __salt__["file.is_link"]("/var/run/netns/{}".format(name)):
__salt__["file.remove"]("/var/run/netns/{}".format(name))
if __salt__["file.is_link"](f"/var/run/netns/{name}"):
__salt__["file.remove"](f"/var/run/netns/{name}")
__salt__["file.symlink"](
"/proc/{}/ns/net".format(pid), "/var/run/netns/{}".format(name)
)
__salt__["file.symlink"](f"/proc/{pid}/ns/net", f"/var/run/netns/{name}")
# Ensure that interface doesn't exists
interface_exists = 0 == __salt__["cmd.retcode"](
@ -4851,12 +4835,10 @@ def add_veth(name, interface_name, bridge=None, path=None):
)
!= 0
):
raise CommandExecutionError(f"Error while creating the veth pair {random_veth}")
if __salt__["cmd.retcode"](f"ip link set dev {random_veth} up") != 0:
raise CommandExecutionError(
"Error while creating the veth pair {}".format(random_veth)
)
if __salt__["cmd.retcode"]("ip link set dev {} up".format(random_veth)) != 0:
raise CommandExecutionError(
"Error while bringing up host-side veth {}".format(random_veth)
f"Error while bringing up host-side veth {random_veth}"
)
# Attach it to the container
@ -4872,7 +4854,7 @@ def add_veth(name, interface_name, bridge=None, path=None):
)
)
__salt__["file.remove"]("/var/run/netns/{}".format(name))
__salt__["file.remove"](f"/var/run/netns/{name}")
if bridge is not None:
__salt__["bridge.addif"](bridge, random_veth)

30
salt/modules/network.py
View file

@ -299,7 +299,7 @@ def _netstat_bsd():
ret = []
if __grains__["kernel"] == "NetBSD":
for addr_family in ("inet", "inet6"):
cmd = "netstat -f {} -an | tail -n+3".format(addr_family)
cmd = f"netstat -f {addr_family} -an | tail -n+3"
out = __salt__["cmd.run"](cmd, python_shell=True)
for line in out.splitlines():
comps = line.split()
@ -382,7 +382,7 @@ def _netstat_sunos():
ret = []
for addr_family in ("inet", "inet6"):
# Lookup TCP connections
cmd = "netstat -f {} -P tcp -an | tail +5".format(addr_family)
cmd = f"netstat -f {addr_family} -P tcp -an | tail +5"
out = __salt__["cmd.run"](cmd, python_shell=True)
for line in out.splitlines():
comps = line.split()
@ -397,7 +397,7 @@ def _netstat_sunos():
}
)
# Lookup UDP connections
cmd = "netstat -f {} -P udp -an | tail +5".format(addr_family)
cmd = f"netstat -f {addr_family} -P udp -an | tail +5"
out = __salt__["cmd.run"](cmd, python_shell=True)
for line in out.splitlines():
comps = line.split()
@ -421,7 +421,7 @@ def _netstat_aix():
## for addr_family in ('inet', 'inet6'):
for addr_family in ("inet",):
# Lookup connections
cmd = "netstat -n -a -f {} | tail -n +3".format(addr_family)
cmd = f"netstat -n -a -f {addr_family} | tail -n +3"
out = __salt__["cmd.run"](cmd, python_shell=True)
for line in out.splitlines():
comps = line.split()
@ -1012,7 +1012,7 @@ def traceroute(host):
"ip": traceline[2],
}
for idx, delay in enumerate(delays):
result["ms{}".format(idx + 1)] = delay
result[f"ms{idx + 1}"] = delay
except IndexError:
result = {}
@ -1454,7 +1454,7 @@ def mod_hostname(hostname):
# Grab the old hostname so we know which hostname to change and then
# change the hostname using the hostname command
if hostname_cmd.endswith("hostnamectl"):
result = __salt__["cmd.run_all"]("{} status".format(hostname_cmd))
result = __salt__["cmd.run_all"](f"{hostname_cmd} status")
if 0 == result["retcode"]:
out = result["stdout"]
for line in out.splitlines():
@ -1486,7 +1486,7 @@ def mod_hostname(hostname):
)
return False
elif not __utils__["platform.is_sunos"]():
__salt__["cmd.run"]("{} {}".format(hostname_cmd, hostname))
__salt__["cmd.run"](f"{hostname_cmd} {hostname}")
else:
__salt__["cmd.run"]("{} -S {}".format(uname_cmd, hostname.split(".")[0]))
@ -1544,7 +1544,7 @@ def mod_hostname(hostname):
)
if __salt__["cmd.run_all"](nirtcfg_cmd)["retcode"] != 0:
raise CommandExecutionError(
"Couldn't set hostname to: {}\n".format(str_hostname)
f"Couldn't set hostname to: {str_hostname}\n"
)
elif __grains__["os_family"] == "OpenBSD":
with __utils__["files.fopen"]("/etc/myname", "w") as fh_:
@ -1720,7 +1720,7 @@ def _get_bufsize_linux(iface):
"""
ret = {"result": False}
cmd = "/sbin/ethtool -g {}".format(iface)
cmd = f"/sbin/ethtool -g {iface}"
out = __salt__["cmd.run"](cmd)
pat = re.compile(r"^(.+):\s+(\d+)$")
suffix = "max-"
@ -1824,7 +1824,7 @@ def routes(family=None):
salt '*' network.routes
"""
if family != "inet" and family != "inet6" and family is not None:
raise CommandExecutionError("Invalid address family {}".format(family))
raise CommandExecutionError(f"Invalid address family {family}")
if __grains__["kernel"] == "Linux":
if not __utils__["path.which"]("netstat"):
@ -1868,7 +1868,7 @@ def default_route(family=None):
salt '*' network.default_route
"""
if family != "inet" and family != "inet6" and family is not None:
raise CommandExecutionError("Invalid address family {}".format(family))
raise CommandExecutionError(f"Invalid address family {family}")
_routes = routes(family)
@ -1926,7 +1926,7 @@ def get_route(ip):
"""
if __grains__["kernel"] == "Linux":
cmd = "ip route get {}".format(ip)
cmd = f"ip route get {ip}"
out = __salt__["cmd.run"](cmd, python_shell=True)
regexp = re.compile(
r"(via\s+(?P<gateway>[\w\.:]+))?\s+dev\s+(?P<interface>[\w\.\:\-]+)\s+.*src\s+(?P<source>[\w\.:]+)"
@ -1950,7 +1950,7 @@ def get_route(ip):
# flags: <UP,DONE,KERNEL>
# recvpipe sendpipe ssthresh rtt,ms rttvar,ms hopcount mtu expire
# 0 0 0 0 0 0 1500 0
cmd = "/usr/sbin/route -n get {}".format(ip)
cmd = f"/usr/sbin/route -n get {ip}"
out = __salt__["cmd.run"](cmd, python_shell=False)
ret = {"destination": ip, "gateway": None, "interface": None, "source": None}
@ -1979,7 +1979,7 @@ def get_route(ip):
# flags: <UP,GATEWAY,DONE,STATIC>
# use mtu expire
# 8352657 0 0
cmd = "route -n get {}".format(ip)
cmd = f"route -n get {ip}"
out = __salt__["cmd.run"](cmd, python_shell=False)
ret = {"destination": ip, "gateway": None, "interface": None, "source": None}
@ -2007,7 +2007,7 @@ def get_route(ip):
# flags: <UP,GATEWAY,HOST,DONE,STATIC>
# recvpipe sendpipe ssthresh rtt,msec rttvar hopcount mtu expire
# 0 0 0 0 0 0 0 -68642
cmd = "route -n get {}".format(ip)
cmd = f"route -n get {ip}"
out = __salt__["cmd.run"](cmd, python_shell=False)
ret = {"destination": ip, "gateway": None, "interface": None, "source": None}

90
salt/modules/nspawn.py
View file

@ -81,7 +81,7 @@ def _ensure_exists(wrapped):
@functools.wraps(wrapped)
def check_exists(name, *args, **kwargs):
if not exists(name):
raise CommandExecutionError("Container '{}' does not exist".format(name))
raise CommandExecutionError(f"Container '{name}' does not exist")
return wrapped(name, *args, **salt.utils.args.clean_kwargs(**kwargs))
return check_exists
@ -115,14 +115,14 @@ def _make_container_root(name):
path = _root(name)
if os.path.exists(path):
__context__["retcode"] = salt.defaults.exitcodes.SALT_BUILD_FAIL
raise CommandExecutionError("Container {} already exists".format(name))
raise CommandExecutionError(f"Container {name} already exists")
else:
try:
os.makedirs(path)
return path
except OSError as exc:
raise CommandExecutionError(
"Unable to make container root directory {}: {}".format(name, exc)
f"Unable to make container root directory {name}: {exc}"
)
@ -132,10 +132,8 @@ def _build_failed(dst, name):
shutil.rmtree(dst)
except OSError as exc:
if exc.errno != errno.ENOENT:
raise CommandExecutionError(
"Unable to cleanup container root dir {}".format(dst)
)
raise CommandExecutionError("Container {} failed to build".format(name))
raise CommandExecutionError(f"Unable to cleanup container root dir {dst}")
raise CommandExecutionError(f"Container {name} failed to build")
def _bootstrap_arch(name, **kwargs):
@ -147,7 +145,7 @@ def _bootstrap_arch(name, **kwargs):
"pacstrap not found, is the arch-install-scripts package installed?"
)
dst = _make_container_root(name)
cmd = "pacstrap -c -d {} base".format(dst)
cmd = f"pacstrap -c -d {dst} base"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
_build_failed(dst, name)
@ -183,7 +181,7 @@ def _bootstrap_debian(name, **kwargs):
)
dst = _make_container_root(name)
cmd = "debootstrap --arch=amd64 {} {}".format(version, dst)
cmd = f"debootstrap --arch=amd64 {version} {dst}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
_build_failed(dst, name)
@ -224,7 +222,7 @@ def _bootstrap_ubuntu(name, **kwargs):
else:
version = "xenial"
dst = _make_container_root(name)
cmd = "debootstrap --arch=amd64 {} {}".format(version, dst)
cmd = f"debootstrap --arch=amd64 {version} {dst}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
_build_failed(dst, name)
@ -258,7 +256,7 @@ def _ensure_systemd(version):
try:
version = int(version)
except ValueError:
raise CommandExecutionError("Invalid version '{}'".format(version))
raise CommandExecutionError(f"Invalid version '{version}'")
try:
installed = _sd_version()
@ -280,7 +278,7 @@ def _machinectl(cmd, output_loglevel="debug", ignore_retcode=False, use_vt=False
"""
prefix = "machinectl --no-legend --no-pager"
return __salt__["cmd.run_all"](
"{} {}".format(prefix, cmd),
f"{prefix} {cmd}",
output_loglevel=output_loglevel,
ignore_retcode=ignore_retcode,
use_vt=use_vt,
@ -350,9 +348,7 @@ def pid(name):
try:
return int(info(name).get("PID"))
except (TypeError, ValueError) as exc:
raise CommandExecutionError(
"Unable to get PID for container '{}': {}".format(name, exc)
)
raise CommandExecutionError(f"Unable to get PID for container '{name}': {exc}")
def run(
@ -706,9 +702,9 @@ def bootstrap_container(name, dist=None, version=None):
dist = __grains__["os"].lower()
log.debug("nspawn.bootstrap: no dist provided, defaulting to '%s'", dist)
try:
return globals()["_bootstrap_{}".format(dist)](name, version=version)
return globals()[f"_bootstrap_{dist}"](name, version=version)
except KeyError:
raise CommandExecutionError('Unsupported distribution "{}"'.format(dist))
raise CommandExecutionError(f'Unsupported distribution "{dist}"')
def _needs_install(name):
@ -786,7 +782,7 @@ def bootstrap_salt(
needs_install = _needs_install(name)
else:
needs_install = True
seeded = retcode(name, "test -e '{}'".format(SEED_MARKER)) == 0
seeded = retcode(name, f"test -e '{SEED_MARKER}'") == 0
tmp = tempfile.mkdtemp()
if seeded and not unconditional_install:
ret = True
@ -803,20 +799,20 @@ def bootstrap_salt(
if needs_install or force_install or unconditional_install:
if install:
rstr = __salt__["test.random_hash"]()
configdir = "/tmp/.c_{}".format(rstr)
run(name, "install -m 0700 -d {}".format(configdir), python_shell=False)
configdir = f"/tmp/.c_{rstr}"
run(name, f"install -m 0700 -d {configdir}", python_shell=False)
bs_ = __salt__["config.gather_bootstrap_script"](
bootstrap=bootstrap_url
)
dest_dir = os.path.join("/tmp", rstr)
for cmd in [
"mkdir -p {}".format(dest_dir),
"chmod 700 {}".format(dest_dir),
f"mkdir -p {dest_dir}",
f"chmod 700 {dest_dir}",
]:
if run_stdout(name, cmd):
log.error("tmpdir %s creation failed (%s)", dest_dir, cmd)
return False
copy_to(name, bs_, "{}/bootstrap.sh".format(dest_dir), makedirs=True)
copy_to(name, bs_, f"{dest_dir}/bootstrap.sh", makedirs=True)
copy_to(name, cfg_files["config"], os.path.join(configdir, "minion"))
copy_to(
name, cfg_files["privkey"], os.path.join(configdir, "minion.pem")
@ -849,7 +845,7 @@ def bootstrap_salt(
stop(name)
# mark seeded upon successful install
if ret:
run(name, "touch '{}'".format(SEED_MARKER), python_shell=False)
run(name, f"touch '{SEED_MARKER}'", python_shell=False)
return ret
@ -933,7 +929,7 @@ def exists(name):
salt myminion nspawn.exists <name>
"""
contextkey = "nspawn.exists.{}".format(name)
contextkey = f"nspawn.exists.{name}"
if contextkey in __context__:
return __context__[contextkey]
__context__[contextkey] = name in list_all()
@ -952,7 +948,7 @@ def state(name):
salt myminion nspawn.state <name>
"""
try:
cmd = "show {} --property=State".format(name)
cmd = f"show {name} --property=State"
return _machinectl(cmd, ignore_retcode=True)["stdout"].split("=")[-1]
except IndexError:
return "stopped"
@ -992,11 +988,9 @@ def info(name, **kwargs):
# Have to parse 'machinectl status' here since 'machinectl show' doesn't
# contain IP address info or OS info. *shakes fist angrily*
c_info = _machinectl("status {}".format(name))
c_info = _machinectl(f"status {name}")
if c_info["retcode"] != 0:
raise CommandExecutionError(
"Unable to get info for container '{}'".format(name)
)
raise CommandExecutionError(f"Unable to get info for container '{name}'")
# Better human-readable names. False means key should be ignored.
key_name_map = {
"Iface": "Network Interface",
@ -1052,7 +1046,7 @@ def enable(name):
salt myminion nspawn.enable <name>
"""
cmd = "systemctl enable systemd-nspawn@{}".format(name)
cmd = f"systemctl enable systemd-nspawn@{name}"
if __salt__["cmd.retcode"](cmd, python_shell=False) != 0:
__context__["retcode"] = salt.defaults.exitcodes.EX_UNAVAILABLE
return False
@ -1070,7 +1064,7 @@ def disable(name):
salt myminion nspawn.enable <name>
"""
cmd = "systemctl disable systemd-nspawn@{}".format(name)
cmd = f"systemctl disable systemd-nspawn@{name}"
if __salt__["cmd.retcode"](cmd, python_shell=False) != 0:
__context__["retcode"] = salt.defaults.exitcodes.EX_UNAVAILABLE
return False
@ -1089,9 +1083,9 @@ def start(name):
salt myminion nspawn.start <name>
"""
if _sd_version() >= 219:
ret = _machinectl("start {}".format(name))
ret = _machinectl(f"start {name}")
else:
cmd = "systemctl start systemd-nspawn@{}".format(name)
cmd = f"systemctl start systemd-nspawn@{name}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
@ -1112,9 +1106,9 @@ def stop(name, kill=False):
action = "terminate"
else:
action = "poweroff"
ret = _machinectl("{} {}".format(action, name))
ret = _machinectl(f"{action} {name}")
else:
cmd = "systemctl stop systemd-nspawn@{}".format(name)
cmd = f"systemctl stop systemd-nspawn@{name}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
@ -1204,7 +1198,7 @@ def reboot(name, kill=False):
"""
if _sd_version() >= 219:
if state(name) == "running":
ret = _machinectl("reboot {}".format(name))
ret = _machinectl(f"reboot {name}")
else:
# 'machinectl reboot' will fail on a stopped container
return start(name)
@ -1214,7 +1208,7 @@ def reboot(name, kill=False):
# we need stop and start the container in separate actions.
# First stop the container
cmd = "systemctl stop systemd-nspawn@{}".format(name)
cmd = f"systemctl stop systemd-nspawn@{name}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
# Now check if successful
if ret["retcode"] != 0:
@ -1222,7 +1216,7 @@ def reboot(name, kill=False):
return False
# Finally, start the container back up. No need to check the retcode a
# second time, it'll be checked below once we exit the if/else block.
cmd = "systemctl start systemd-nspawn@{}".format(name)
cmd = f"systemctl start systemd-nspawn@{name}"
ret = __salt__["cmd.run_all"](cmd, python_shell=False)
if ret["retcode"] != 0:
@ -1257,15 +1251,13 @@ def remove(name, stop=False):
salt '*' nspawn.remove foo stop=True
"""
if not stop and state(name) != "stopped":
raise CommandExecutionError("Container '{}' is not stopped".format(name))
raise CommandExecutionError(f"Container '{name}' is not stopped")
def _failed_remove(name, exc):
raise CommandExecutionError(
"Unable to remove container '{}': {}".format(name, exc)
)
raise CommandExecutionError(f"Unable to remove container '{name}': {exc}")
if _sd_version() >= 219:
ret = _machinectl("remove {}".format(name))
ret = _machinectl(f"remove {name}")
if ret["retcode"] != 0:
__context__["retcode"] = salt.defaults.exitcodes.EX_UNAVAILABLE
_failed_remove(name, ret["stderr"])
@ -1315,10 +1307,10 @@ def copy_to(name, source, dest, overwrite=False, makedirs=False):
if source.startswith("salt://"):
cached_source = __salt__["cp.cache_file"](source)
if not cached_source:
raise CommandExecutionError("Unable to cache {}".format(source))
raise CommandExecutionError(f"Unable to cache {source}")
path = cached_source
except AttributeError:
raise SaltInvocationError("Invalid source file {}".format(source))
raise SaltInvocationError(f"Invalid source file {source}")
if _sd_version() >= 219:
# TODO: Use machinectl copy-to
@ -1346,13 +1338,13 @@ def _pull_image(pull_type, image, name, **kwargs):
"""
_ensure_systemd(219)
if exists(name):
raise SaltInvocationError("Container '{}' already exists".format(name))
raise SaltInvocationError(f"Container '{name}' already exists")
if pull_type in ("raw", "tar"):
valid_kwargs = ("verify",)
elif pull_type == "dkr":
valid_kwargs = ("index",)
else:
raise SaltInvocationError("Unsupported image type '{}'".format(pull_type))
raise SaltInvocationError(f"Unsupported image type '{pull_type}'")
kwargs = salt.utils.args.clean_kwargs(**kwargs)
bad_kwargs = {
@ -1384,7 +1376,7 @@ def _pull_image(pull_type, image, name, **kwargs):
else:
if verify not in ("signature", "checksum"):
_bad_verify()
pull_opts.append("--verify={}".format(verify))
pull_opts.append(f"--verify={verify}")
elif pull_type == "dkr":
# No need to validate the index URL, machinectl will take care of this

36
salt/modules/vagrant.py
View file

@ -62,7 +62,7 @@ def _build_sdb_uri(key):
Salt node id's are used as the key for vm_ dicts.
"""
return "{}{}".format(VAGRANT_SDB_URL, key)
return f"{VAGRANT_SDB_URL}{key}"
def _build_machine_uri(machine, cwd):
@ -73,7 +73,7 @@ def _build_machine_uri(machine, cwd):
never collide with a Salt node id -- which is important since we
will be storing both in the same table.
"""
key = "{}?{}".format(machine, os.path.abspath(cwd))
key = f"{machine}?{os.path.abspath(cwd)}"
return _build_sdb_uri(key)
@ -102,9 +102,7 @@ def get_vm_info(name):
"Probable sdb driver not found. Check your configuration."
)
if vm_ is None or "machine" not in vm_:
raise SaltInvocationError(
"No Vagrant machine defined for Salt_id {}".format(name)
)
raise SaltInvocationError(f"No Vagrant machine defined for Salt_id {name}")
return vm_
@ -161,7 +159,7 @@ def _vagrant_ssh_config(vm_):
"""
machine = vm_["machine"]
log.info("requesting vagrant ssh-config for VM %s", machine or "(default)")
cmd = "vagrant ssh-config {}".format(machine)
cmd = f"vagrant ssh-config {machine}"
reply = __salt__["cmd.shell"](
cmd, runas=vm_.get("runas"), cwd=vm_.get("cwd"), ignore_retcode=True
)
@ -305,12 +303,12 @@ def vm_state(name="", cwd=None):
else:
if not cwd:
raise SaltInvocationError(
"Path to Vagranfile must be defined, but cwd={}".format(cwd)
f"Path to Vagranfile must be defined, but cwd={cwd}"
)
machine = ""
info = []
cmd = "vagrant status {}".format(machine)
cmd = f"vagrant status {machine}"
reply = __salt__["cmd.shell"](cmd, cwd)
log.info("--->\n%s", reply)
for line in reply.split("\n"): # build a list of the text reply
@ -404,13 +402,11 @@ def _start(
try:
machine = vm_["machine"]
except KeyError:
raise SaltInvocationError(
"No Vagrant machine defined for Salt_id {}".format(name)
)
raise SaltInvocationError(f"No Vagrant machine defined for Salt_id {name}")
vagrant_provider = vm_.get("vagrant_provider", "")
provider_ = "--provider={}".format(vagrant_provider) if vagrant_provider else ""
cmd = "vagrant up {} {}".format(machine, provider_)
provider_ = f"--provider={vagrant_provider}" if vagrant_provider else ""
cmd = f"vagrant up {machine} {provider_}"
ret = __salt__["cmd.run_all"](
cmd, runas=vm_.get("runas"), cwd=vm_.get("cwd"), output_loglevel="info"
)
@ -424,7 +420,7 @@ def _start(
break
if ret["retcode"] == 0:
return 'Started "{}" using Vagrant machine "{}".'.format(name, machine)
return f'Started "{name}" using Vagrant machine "{machine}".'
return False
@ -458,7 +454,7 @@ def stop(name):
vm_ = get_vm_info(name)
machine = vm_["machine"]
cmd = "vagrant halt {}".format(machine)
cmd = f"vagrant halt {machine}"
ret = __salt__["cmd.retcode"](cmd, runas=vm_.get("runas"), cwd=vm_.get("cwd"))
return ret == 0
@ -476,7 +472,7 @@ def pause(name):
vm_ = get_vm_info(name)
machine = vm_["machine"]
cmd = "vagrant suspend {}".format(machine)
cmd = f"vagrant suspend {machine}"
ret = __salt__["cmd.retcode"](cmd, runas=vm_.get("runas"), cwd=vm_.get("cwd"))
return ret == 0
@ -498,7 +494,7 @@ def reboot(name, provision=False):
machine = vm_["machine"]
prov = "--provision" if provision else ""
cmd = "vagrant reload {} {}".format(machine, prov)
cmd = f"vagrant reload {machine} {prov}"
ret = __salt__["cmd.retcode"](cmd, runas=vm_.get("runas"), cwd=vm_.get("cwd"))
return ret == 0
@ -518,14 +514,14 @@ def destroy(name):
vm_ = get_vm_info(name)
machine = vm_["machine"]
cmd = "vagrant destroy -f {}".format(machine)
cmd = f"vagrant destroy -f {machine}"
ret = __salt__["cmd.run_all"](
cmd, runas=vm_.get("runas"), cwd=vm_.get("cwd"), output_loglevel="info"
)
if ret["retcode"] == 0:
_erase_vm_info(name)
return "Destroyed VM {}".format(name)
return f"Destroyed VM {name}"
return False
@ -691,6 +687,6 @@ def get_ssh_config(name, network_mask="", get_private_key=False):
ans["private_key"] = salt.utils.stringutils.to_unicode(pks.read())
except OSError as e:
raise CommandExecutionError(
"Error processing Vagrant private key file: {}".format(e)
f"Error processing Vagrant private key file: {e}"
)
return ans

2
tests/pytests/unit/modules/test_network.py
View file

@ -17,7 +17,7 @@ log = logging.getLogger(__name__)
@pytest.fixture
def configure_loader_modules():
def configure_loader_modules(minion_opts):
## return {networkmod: {}}
utils = salt.loader.utils(
minion_opts, whitelist=["network", "path", "platform", "stringutils"]