mirror of
https://github.com/containers/ansible-podman-collections.git
synced 2026-02-04 07:11:49 +00:00
6ff93e7559
* podman_container_lib: Added checks for volume opts Changed the diffparam_volume function to include the volume mount opts. Signed-off-by: Lucas Benedito <lbenedit@redhat.com> * Add test for volume mount options Signed-off-by: Lucas Benedito <lbenedit@redhat.com> --------- Signed-off-by: Lucas Benedito <lbenedit@redhat.com>
2055 lines
73 KiB
Python
2055 lines
73 KiB
Python
from __future__ import absolute_import, division, print_function
|
|
import json # noqa: F402
|
|
import os # noqa: F402
|
|
import shlex # noqa: F402
|
|
|
|
from ansible.module_utils._text import to_bytes, to_native # noqa: F402
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
|
|
LooseVersion,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
|
|
lower_keys,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
|
|
generate_systemd,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
|
|
delete_systemd,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
|
|
diff_generic,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
|
|
createcommand,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.quadlet import (
|
|
create_quadlet_state,
|
|
)
|
|
from ansible_collections.containers.podman.plugins.module_utils.podman.quadlet import (
|
|
ContainerQuadlet,
|
|
)
|
|
|
|
|
|
__metaclass__ = type
|
|
|
|
ARGUMENTS_SPEC_CONTAINER = dict(
|
|
name=dict(required=True, type="str"),
|
|
executable=dict(default="podman", type="str"),
|
|
state=dict(
|
|
type="str",
|
|
default="started",
|
|
choices=["absent", "present", "stopped", "started", "created", "quadlet"],
|
|
),
|
|
image=dict(type="str"),
|
|
annotation=dict(type="dict"),
|
|
arch=dict(type="str"),
|
|
attach=dict(type="list", elements="str", choices=["stdout", "stderr", "stdin"]),
|
|
authfile=dict(type="path"),
|
|
blkio_weight=dict(type="int"),
|
|
blkio_weight_device=dict(type="dict"),
|
|
cap_add=dict(type="list", elements="str", aliases=["capabilities"]),
|
|
cap_drop=dict(type="list", elements="str"),
|
|
cgroup_conf=dict(type="dict"),
|
|
cgroup_parent=dict(type="path"),
|
|
cgroupns=dict(type="str"),
|
|
cgroups=dict(type="str"),
|
|
chrootdirs=dict(type="str"),
|
|
cidfile=dict(type="path"),
|
|
cmd_args=dict(type="list", elements="str"),
|
|
conmon_pidfile=dict(type="path"),
|
|
command=dict(type="raw"),
|
|
cpu_period=dict(type="int"),
|
|
cpu_quota=dict(type="int"),
|
|
cpu_rt_period=dict(type="int"),
|
|
cpu_rt_runtime=dict(type="int"),
|
|
cpu_shares=dict(type="int"),
|
|
cpus=dict(type="str"),
|
|
cpuset_cpus=dict(type="str"),
|
|
cpuset_mems=dict(type="str"),
|
|
decryption_key=dict(type="str", no_log=False),
|
|
delete_depend=dict(type="bool"),
|
|
delete_time=dict(type="str"),
|
|
delete_volumes=dict(type="bool"),
|
|
detach=dict(type="bool", default=True),
|
|
debug=dict(type="bool", default=False),
|
|
detach_keys=dict(type="str", no_log=False),
|
|
device=dict(type="list", elements="str"),
|
|
device_cgroup_rule=dict(type="str"),
|
|
device_read_bps=dict(type="list", elements="str"),
|
|
device_read_iops=dict(type="list", elements="str"),
|
|
device_write_bps=dict(type="list", elements="str"),
|
|
device_write_iops=dict(type="list", elements="str"),
|
|
dns=dict(type="list", elements="str", aliases=["dns_servers"]),
|
|
dns_option=dict(type="str", aliases=["dns_opts"]),
|
|
dns_search=dict(type="list", elements="str", aliases=["dns_search_domains"]),
|
|
entrypoint=dict(type="str"),
|
|
env=dict(type="dict"),
|
|
env_file=dict(type="list", elements="path", aliases=["env_files"]),
|
|
env_host=dict(type="bool"),
|
|
env_merge=dict(type="dict"),
|
|
etc_hosts=dict(type="dict", aliases=["add_hosts"]),
|
|
expose=dict(type="list", elements="str", aliases=["exposed", "exposed_ports"]),
|
|
force_restart=dict(type="bool", default=False, aliases=["restart"]),
|
|
force_delete=dict(type="bool", default=True),
|
|
generate_systemd=dict(type="dict", default={}),
|
|
gidmap=dict(type="list", elements="str"),
|
|
gpus=dict(type="str"),
|
|
group_add=dict(type="list", elements="str", aliases=["groups"]),
|
|
group_entry=dict(type="str"),
|
|
healthcheck=dict(type="str", aliases=["health_cmd"]),
|
|
healthcheck_interval=dict(type="str", aliases=["health_interval"]),
|
|
healthcheck_retries=dict(type="int", aliases=["health_retries"]),
|
|
healthcheck_start_period=dict(type="str", aliases=["health_start_period"]),
|
|
health_startup_cmd=dict(type="str"),
|
|
health_startup_interval=dict(type="str"),
|
|
health_startup_retries=dict(type="int"),
|
|
health_startup_success=dict(type="int"),
|
|
health_startup_timeout=dict(type="str"),
|
|
healthcheck_timeout=dict(type="str", aliases=["health_timeout"]),
|
|
healthcheck_failure_action=dict(
|
|
type="str",
|
|
choices=["none", "kill", "restart", "stop"],
|
|
aliases=["health_on_failure"],
|
|
),
|
|
hooks_dir=dict(type="list", elements="str"),
|
|
hostname=dict(type="str"),
|
|
hostuser=dict(type="str"),
|
|
http_proxy=dict(type="bool"),
|
|
image_volume=dict(type="str", choices=["bind", "tmpfs", "ignore"]),
|
|
image_strict=dict(type="bool", default=False),
|
|
init=dict(type="bool"),
|
|
init_ctr=dict(type="str", choices=["once", "always"]),
|
|
init_path=dict(type="str"),
|
|
interactive=dict(type="bool"),
|
|
ip=dict(type="str"),
|
|
ip6=dict(type="str"),
|
|
ipc=dict(type="str", aliases=["ipc_mode"]),
|
|
kernel_memory=dict(type="str"),
|
|
label=dict(type="dict", aliases=["labels"]),
|
|
label_file=dict(type="str"),
|
|
log_driver=dict(type="str", choices=["k8s-file", "journald", "json-file"]),
|
|
log_level=dict(
|
|
type="str", choices=["debug", "info", "warn", "error", "fatal", "panic"]
|
|
),
|
|
log_opt=dict(
|
|
type="dict",
|
|
aliases=["log_options"],
|
|
options=dict(
|
|
max_size=dict(type="str"), path=dict(type="str"), tag=dict(type="str")
|
|
),
|
|
),
|
|
mac_address=dict(type="str"),
|
|
memory=dict(type="str"),
|
|
memory_reservation=dict(type="str"),
|
|
memory_swap=dict(type="str"),
|
|
memory_swappiness=dict(type="int"),
|
|
mount=dict(type="list", elements="str", aliases=["mounts"]),
|
|
network=dict(type="list", elements="str", aliases=["net", "network_mode"]),
|
|
network_aliases=dict(type="list", elements="str", aliases=["network_alias"]),
|
|
no_healthcheck=dict(type="bool"),
|
|
no_hosts=dict(type="bool"),
|
|
oom_kill_disable=dict(type="bool"),
|
|
oom_score_adj=dict(type="int"),
|
|
os=dict(type="str"),
|
|
passwd=dict(type="bool", no_log=False),
|
|
passwd_entry=dict(type="str", no_log=False),
|
|
personality=dict(type="str"),
|
|
pid=dict(type="str", aliases=["pid_mode"]),
|
|
pid_file=dict(type="path"),
|
|
pids_limit=dict(type="str"),
|
|
platform=dict(type="str"),
|
|
pod=dict(type="str"),
|
|
pod_id_file=dict(type="path"),
|
|
preserve_fd=dict(type="list", elements="str"),
|
|
preserve_fds=dict(type="str"),
|
|
privileged=dict(type="bool"),
|
|
publish=dict(
|
|
type="list", elements="str", aliases=["ports", "published", "published_ports"]
|
|
),
|
|
publish_all=dict(type="bool"),
|
|
pull=dict(type="str", choices=["always", "missing", "never", "newer"]),
|
|
quadlet_dir=dict(type="path"),
|
|
quadlet_filename=dict(type="str"),
|
|
quadlet_file_mode=dict(type="raw"),
|
|
quadlet_options=dict(type="list", elements="str"),
|
|
rdt_class=dict(type="str"),
|
|
read_only=dict(type="bool"),
|
|
read_only_tmpfs=dict(type="bool"),
|
|
recreate=dict(type="bool", default=False),
|
|
requires=dict(type="list", elements="str"),
|
|
restart_policy=dict(type="str"),
|
|
restart_time=dict(type="str"),
|
|
retry=dict(type="int"),
|
|
retry_delay=dict(type="str"),
|
|
rm=dict(type="bool", aliases=["remove", "auto_remove"]),
|
|
rmi=dict(type="bool"),
|
|
rootfs=dict(type="bool"),
|
|
seccomp_policy=dict(type="str"),
|
|
secrets=dict(type="list", elements="str", no_log=True),
|
|
sdnotify=dict(type="str"),
|
|
security_opt=dict(type="list", elements="str"),
|
|
shm_size=dict(type="str"),
|
|
shm_size_systemd=dict(type="str"),
|
|
sig_proxy=dict(type="bool"),
|
|
stop_signal=dict(type="int"),
|
|
stop_timeout=dict(type="int"),
|
|
stop_time=dict(type="str"),
|
|
subgidname=dict(type="str"),
|
|
subuidname=dict(type="str"),
|
|
sysctl=dict(type="dict"),
|
|
systemd=dict(type="str"),
|
|
timeout=dict(type="int"),
|
|
timezone=dict(type="str"),
|
|
tls_verify=dict(type="bool"),
|
|
tmpfs=dict(type="dict"),
|
|
tty=dict(type="bool"),
|
|
uidmap=dict(type="list", elements="str"),
|
|
ulimit=dict(type="list", elements="str", aliases=["ulimits"]),
|
|
umask=dict(type="str"),
|
|
unsetenv=dict(type="list", elements="str"),
|
|
unsetenv_all=dict(type="bool"),
|
|
user=dict(type="str"),
|
|
userns=dict(type="str", aliases=["userns_mode"]),
|
|
uts=dict(type="str"),
|
|
variant=dict(type="str"),
|
|
volume=dict(type="list", elements="str", aliases=["volumes"]),
|
|
volumes_from=dict(type="list", elements="str"),
|
|
workdir=dict(type="str", aliases=["working_dir"]),
|
|
)
|
|
|
|
|
|
def init_options():
|
|
default = {}
|
|
opts = ARGUMENTS_SPEC_CONTAINER
|
|
for k, v in opts.items():
|
|
if "default" in v:
|
|
default[k] = v["default"]
|
|
else:
|
|
default[k] = None
|
|
return default
|
|
|
|
|
|
def update_options(opts_dict, container):
|
|
def to_bool(x):
|
|
return str(x).lower() not in ["no", "false"]
|
|
|
|
aliases = {}
|
|
for k, v in ARGUMENTS_SPEC_CONTAINER.items():
|
|
if "aliases" in v:
|
|
for alias in v["aliases"]:
|
|
aliases[alias] = k
|
|
for k in list(container):
|
|
if k in aliases:
|
|
key = aliases[k]
|
|
container[key] = container.pop(k)
|
|
else:
|
|
key = k
|
|
if ARGUMENTS_SPEC_CONTAINER[key]["type"] == "list" and not isinstance(
|
|
container[key], list
|
|
):
|
|
opts_dict[key] = [container[key]]
|
|
elif ARGUMENTS_SPEC_CONTAINER[key]["type"] == "bool" and not isinstance(
|
|
container[key], bool
|
|
):
|
|
opts_dict[key] = to_bool(container[key])
|
|
elif ARGUMENTS_SPEC_CONTAINER[key]["type"] == "int" and not isinstance(
|
|
container[key], int
|
|
):
|
|
opts_dict[key] = int(container[key])
|
|
else:
|
|
opts_dict[key] = container[key]
|
|
|
|
return opts_dict
|
|
|
|
|
|
def set_container_opts(input_vars):
|
|
default_options_templ = init_options()
|
|
options_dict = update_options(default_options_templ, input_vars)
|
|
return options_dict
|
|
|
|
|
|
class PodmanModuleParams:
|
|
"""Creates list of arguments for podman CLI command.
|
|
|
|
Arguments:
|
|
action {str} -- action type from 'run', 'stop', 'create', 'delete',
|
|
'start', 'restart'
|
|
params {dict} -- dictionary of module parameters
|
|
|
|
"""
|
|
|
|
def __init__(self, action, params, podman_version, module):
|
|
self.params = params
|
|
self.action = action
|
|
self.podman_version = podman_version
|
|
self.module = module
|
|
|
|
def construct_command_from_params(self):
|
|
"""Create a podman command from given module parameters.
|
|
|
|
Returns:
|
|
list -- list of byte strings for Popen command
|
|
"""
|
|
if self.action in ["start", "stop", "delete", "restart"]:
|
|
return self.start_stop_delete()
|
|
if self.action in ["create", "run"]:
|
|
cmd = [self.action, "--name", self.params["name"]]
|
|
all_param_methods = [
|
|
func
|
|
for func in dir(self)
|
|
if callable(getattr(self, func)) and func.startswith("addparam")
|
|
]
|
|
params_set = (i for i in self.params if self.params[i] is not None)
|
|
for param in params_set:
|
|
func_name = "_".join(["addparam", param])
|
|
if func_name in all_param_methods:
|
|
cmd = getattr(self, func_name)(cmd)
|
|
cmd.append(self.params["image"])
|
|
if self.params["command"]:
|
|
if isinstance(self.params["command"], list):
|
|
cmd += self.params["command"]
|
|
else:
|
|
cmd += self.params["command"].split()
|
|
return [to_bytes(i, errors="surrogate_or_strict") for i in cmd]
|
|
|
|
def start_stop_delete(self):
|
|
|
|
def complete_params(cmd):
|
|
if self.params["attach"] and self.action == "start":
|
|
cmd.append("--attach")
|
|
if (
|
|
self.params["detach"] is False
|
|
and self.action == "start"
|
|
and "--attach" not in cmd
|
|
):
|
|
cmd.append("--attach")
|
|
if self.params["detach_keys"] and self.action == "start":
|
|
cmd += ["--detach-keys", self.params["detach_keys"]]
|
|
if self.params["sig_proxy"] and self.action == "start":
|
|
cmd.append("--sig-proxy")
|
|
if self.params["stop_time"] and self.action == "stop":
|
|
cmd += ["--time", self.params["stop_time"]]
|
|
if self.params["restart_time"] and self.action == "restart":
|
|
cmd += ["--time", self.params["restart_time"]]
|
|
if self.params["delete_depend"] and self.action == "delete":
|
|
cmd.append("--depend")
|
|
if self.params["delete_time"] and self.action == "delete":
|
|
cmd += ["--time", self.params["delete_time"]]
|
|
if self.params["delete_volumes"] and self.action == "delete":
|
|
cmd.append("--volumes")
|
|
if self.params["force_delete"] and self.action == "delete":
|
|
cmd.append("--force")
|
|
return cmd
|
|
|
|
if self.action in ["stop", "start", "restart"]:
|
|
cmd = complete_params([self.action]) + [self.params["name"]]
|
|
return [to_bytes(i, errors="surrogate_or_strict") for i in cmd]
|
|
|
|
if self.action == "delete":
|
|
cmd = complete_params(["rm"]) + [self.params["name"]]
|
|
return [to_bytes(i, errors="surrogate_or_strict") for i in cmd]
|
|
|
|
def check_version(self, param, minv=None, maxv=None):
|
|
if minv and LooseVersion(minv) > LooseVersion(self.podman_version):
|
|
self.module.fail_json(
|
|
msg="Parameter %s is supported from podman "
|
|
"version %s only! Current version is %s"
|
|
% (param, minv, self.podman_version)
|
|
)
|
|
if maxv and LooseVersion(maxv) < LooseVersion(self.podman_version):
|
|
self.module.fail_json(
|
|
msg="Parameter %s is supported till podman "
|
|
"version %s only! Current version is %s"
|
|
% (param, minv, self.podman_version)
|
|
)
|
|
|
|
def addparam_annotation(self, c):
|
|
for annotate in self.params["annotation"].items():
|
|
c += ["--annotation", "=".join(annotate)]
|
|
return c
|
|
|
|
def addparam_arch(self, c):
|
|
return c + ["--arch=%s" % self.params["arch"]]
|
|
|
|
def addparam_attach(self, c):
|
|
for attach in self.params["attach"]:
|
|
c += ["--attach=%s" % attach]
|
|
return c
|
|
|
|
def addparam_authfile(self, c):
|
|
return c + ["--authfile", self.params["authfile"]]
|
|
|
|
def addparam_blkio_weight(self, c):
|
|
return c + ["--blkio-weight", self.params["blkio_weight"]]
|
|
|
|
def addparam_blkio_weight_device(self, c):
|
|
for blkio in self.params["blkio_weight_device"].items():
|
|
c += ["--blkio-weight-device", ":".join(blkio)]
|
|
return c
|
|
|
|
def addparam_cap_add(self, c):
|
|
for cap_add in self.params["cap_add"]:
|
|
c += ["--cap-add", cap_add]
|
|
return c
|
|
|
|
def addparam_cap_drop(self, c):
|
|
for cap_drop in self.params["cap_drop"]:
|
|
c += ["--cap-drop", cap_drop]
|
|
return c
|
|
|
|
def addparam_cgroups(self, c):
|
|
self.check_version("--cgroups", minv="1.6.0")
|
|
return c + ["--cgroups=%s" % self.params["cgroups"]]
|
|
|
|
def addparam_cgroupns(self, c):
|
|
self.check_version("--cgroupns", minv="1.6.2")
|
|
return c + ["--cgroupns=%s" % self.params["cgroupns"]]
|
|
|
|
def addparam_cgroup_parent(self, c):
|
|
return c + ["--cgroup-parent", self.params["cgroup_parent"]]
|
|
|
|
def addparam_cgroup_conf(self, c):
|
|
for cgroup in self.params["cgroup_conf"].items():
|
|
c += ["--cgroup-conf=%s" % "=".join([str(i) for i in cgroup])]
|
|
return c
|
|
|
|
def addparam_chrootdirs(self, c):
|
|
return c + ["--chrootdirs", self.params["chrootdirs"]]
|
|
|
|
def addparam_cidfile(self, c):
|
|
return c + ["--cidfile", self.params["cidfile"]]
|
|
|
|
def addparam_conmon_pidfile(self, c):
|
|
return c + ["--conmon-pidfile", self.params["conmon_pidfile"]]
|
|
|
|
def addparam_cpu_period(self, c):
|
|
return c + ["--cpu-period", self.params["cpu_period"]]
|
|
|
|
def addparam_cpu_quota(self, c):
|
|
return c + ["--cpu-quota", self.params["cpu_quota"]]
|
|
|
|
def addparam_cpu_rt_period(self, c):
|
|
return c + ["--cpu-rt-period", self.params["cpu_rt_period"]]
|
|
|
|
def addparam_cpu_rt_runtime(self, c):
|
|
return c + ["--cpu-rt-runtime", self.params["cpu_rt_runtime"]]
|
|
|
|
def addparam_cpu_shares(self, c):
|
|
return c + ["--cpu-shares", self.params["cpu_shares"]]
|
|
|
|
def addparam_cpus(self, c):
|
|
return c + ["--cpus", self.params["cpus"]]
|
|
|
|
def addparam_cpuset_cpus(self, c):
|
|
return c + ["--cpuset-cpus", self.params["cpuset_cpus"]]
|
|
|
|
def addparam_cpuset_mems(self, c):
|
|
return c + ["--cpuset-mems", self.params["cpuset_mems"]]
|
|
|
|
def addparam_decryption_key(self, c):
|
|
return c + ["--decryption-key=%s" % self.params["decryption_key"]]
|
|
|
|
def addparam_detach(self, c):
|
|
# Remove detach from create command and don't set if attach is true
|
|
if self.action == "create" or self.params["attach"]:
|
|
return c
|
|
return c + ["--detach=%s" % self.params["detach"]]
|
|
|
|
def addparam_detach_keys(self, c):
|
|
return c + ["--detach-keys", self.params["detach_keys"]]
|
|
|
|
def addparam_device(self, c):
|
|
for dev in self.params["device"]:
|
|
c += ["--device", dev]
|
|
return c
|
|
|
|
def addparam_device_cgroup_rule(self, c):
|
|
return c + ["--device-cgroup-rule=%s" % self.params["device_cgroup_rule"]]
|
|
|
|
def addparam_device_read_bps(self, c):
|
|
for dev in self.params["device_read_bps"]:
|
|
c += ["--device-read-bps", dev]
|
|
return c
|
|
|
|
def addparam_device_read_iops(self, c):
|
|
for dev in self.params["device_read_iops"]:
|
|
c += ["--device-read-iops", dev]
|
|
return c
|
|
|
|
def addparam_device_write_bps(self, c):
|
|
for dev in self.params["device_write_bps"]:
|
|
c += ["--device-write-bps", dev]
|
|
return c
|
|
|
|
def addparam_device_write_iops(self, c):
|
|
for dev in self.params["device_write_iops"]:
|
|
c += ["--device-write-iops", dev]
|
|
return c
|
|
|
|
def addparam_dns(self, c):
|
|
return c + ["--dns", ",".join(self.params["dns"])]
|
|
|
|
def addparam_dns_option(self, c):
|
|
return c + ["--dns-option", self.params["dns_option"]]
|
|
|
|
def addparam_dns_search(self, c):
|
|
for search in self.params["dns_search"]:
|
|
c += ["--dns-search", search]
|
|
return c
|
|
|
|
def addparam_entrypoint(self, c):
|
|
return c + ["--entrypoint=%s" % self.params["entrypoint"]]
|
|
|
|
def addparam_env(self, c):
|
|
for env_value in self.params["env"].items():
|
|
c += [
|
|
"--env",
|
|
b"=".join(
|
|
[to_bytes(k, errors="surrogate_or_strict") for k in env_value]
|
|
),
|
|
]
|
|
return c
|
|
|
|
def addparam_env_file(self, c):
|
|
for env_file in self.params["env_file"]:
|
|
c += ["--env-file", env_file]
|
|
return c
|
|
|
|
def addparam_env_host(self, c):
|
|
self.check_version("--env-host", minv="1.5.0")
|
|
return c + ["--env-host=%s" % self.params["env_host"]]
|
|
|
|
# Exception for etc_hosts and add-host
|
|
def addparam_etc_hosts(self, c):
|
|
for host_ip in self.params["etc_hosts"].items():
|
|
c += ["--add-host", ":".join(host_ip)]
|
|
return c
|
|
|
|
def addparam_env_merge(self, c):
|
|
for env_merge in self.params["env_merge"].items():
|
|
c += [
|
|
"--env-merge",
|
|
b"=".join(
|
|
[to_bytes(k, errors="surrogate_or_strict") for k in env_merge]
|
|
),
|
|
]
|
|
return c
|
|
|
|
def addparam_expose(self, c):
|
|
for exp in self.params["expose"]:
|
|
c += ["--expose", exp]
|
|
return c
|
|
|
|
def addparam_gidmap(self, c):
|
|
for gidmap in self.params["gidmap"]:
|
|
c += ["--gidmap", gidmap]
|
|
return c
|
|
|
|
def addparam_gpus(self, c):
|
|
return c + ["--gpus", self.params["gpus"]]
|
|
|
|
def addparam_group_add(self, c):
|
|
for g in self.params["group_add"]:
|
|
c += ["--group-add", g]
|
|
return c
|
|
|
|
def addparam_group_entry(self, c):
|
|
return c + ["--group-entry", self.params["group_entry"]]
|
|
|
|
# Exception for healthcheck and healthcheck-command
|
|
def addparam_healthcheck(self, c):
|
|
return c + ["--healthcheck-command", self.params["healthcheck"]]
|
|
|
|
def addparam_healthcheck_interval(self, c):
|
|
return c + ["--healthcheck-interval", self.params["healthcheck_interval"]]
|
|
|
|
def addparam_healthcheck_retries(self, c):
|
|
return c + ["--healthcheck-retries", self.params["healthcheck_retries"]]
|
|
|
|
def addparam_healthcheck_start_period(self, c):
|
|
return c + [
|
|
"--healthcheck-start-period",
|
|
self.params["healthcheck_start_period"],
|
|
]
|
|
|
|
def addparam_health_startup_cmd(self, c):
|
|
return c + ["--health-startup-cmd", self.params["health_startup_cmd"]]
|
|
|
|
def addparam_health_startup_interval(self, c):
|
|
return c + ["--health-startup-interval", self.params["health_startup_interval"]]
|
|
|
|
def addparam_healthcheck_timeout(self, c):
|
|
return c + ["--healthcheck-timeout", self.params["healthcheck_timeout"]]
|
|
|
|
def addparam_health_startup_retries(self, c):
|
|
return c + ["--health-startup-retries", self.params["health_startup_retries"]]
|
|
|
|
def addparam_health_startup_success(self, c):
|
|
return c + ["--health-startup-success", self.params["health_startup_success"]]
|
|
|
|
def addparam_health_startup_timeout(self, c):
|
|
return c + ["--health-startup-timeout", self.params["health_startup_timeout"]]
|
|
|
|
def addparam_healthcheck_failure_action(self, c):
|
|
return c + ["--health-on-failure", self.params["healthcheck_failure_action"]]
|
|
|
|
def addparam_hooks_dir(self, c):
|
|
for hook_dir in self.params["hooks_dir"]:
|
|
c += ["--hooks-dir=%s" % hook_dir]
|
|
return c
|
|
|
|
def addparam_hostname(self, c):
|
|
return c + ["--hostname", self.params["hostname"]]
|
|
|
|
def addparam_hostuser(self, c):
|
|
return c + ["--hostuser", self.params["hostuser"]]
|
|
|
|
def addparam_http_proxy(self, c):
|
|
return c + ["--http-proxy=%s" % self.params["http_proxy"]]
|
|
|
|
def addparam_image_volume(self, c):
|
|
return c + ["--image-volume", self.params["image_volume"]]
|
|
|
|
def addparam_init(self, c):
|
|
if self.params["init"]:
|
|
c += ["--init"]
|
|
return c
|
|
|
|
def addparam_init_path(self, c):
|
|
return c + ["--init-path", self.params["init_path"]]
|
|
|
|
def addparam_init_ctr(self, c):
|
|
return c + ["--init-ctr", self.params["init_ctr"]]
|
|
|
|
def addparam_interactive(self, c):
|
|
return c + ["--interactive=%s" % self.params["interactive"]]
|
|
|
|
def addparam_ip(self, c):
|
|
return c + ["--ip", self.params["ip"]]
|
|
|
|
def addparam_ip6(self, c):
|
|
return c + ["--ip6", self.params["ip6"]]
|
|
|
|
def addparam_ipc(self, c):
|
|
return c + ["--ipc", self.params["ipc"]]
|
|
|
|
def addparam_kernel_memory(self, c):
|
|
return c + ["--kernel-memory", self.params["kernel_memory"]]
|
|
|
|
def addparam_label(self, c):
|
|
for label in self.params["label"].items():
|
|
c += [
|
|
"--label",
|
|
b"=".join([to_bytes(la, errors="surrogate_or_strict") for la in label]),
|
|
]
|
|
return c
|
|
|
|
def addparam_label_file(self, c):
|
|
return c + ["--label-file", self.params["label_file"]]
|
|
|
|
def addparam_log_driver(self, c):
|
|
return c + ["--log-driver", self.params["log_driver"]]
|
|
|
|
def addparam_log_opt(self, c):
|
|
for k, v in self.params["log_opt"].items():
|
|
if v is not None:
|
|
c += [
|
|
"--log-opt",
|
|
b"=".join(
|
|
[
|
|
to_bytes(
|
|
k.replace("max_size", "max-size"),
|
|
errors="surrogate_or_strict",
|
|
),
|
|
to_bytes(v, errors="surrogate_or_strict"),
|
|
]
|
|
),
|
|
]
|
|
return c
|
|
|
|
def addparam_log_level(self, c):
|
|
return c + ["--log-level", self.params["log_level"]]
|
|
|
|
def addparam_mac_address(self, c):
|
|
return c + ["--mac-address", self.params["mac_address"]]
|
|
|
|
def addparam_memory(self, c):
|
|
return c + ["--memory", self.params["memory"]]
|
|
|
|
def addparam_memory_reservation(self, c):
|
|
return c + ["--memory-reservation", self.params["memory_reservation"]]
|
|
|
|
def addparam_memory_swap(self, c):
|
|
return c + ["--memory-swap", self.params["memory_swap"]]
|
|
|
|
def addparam_memory_swappiness(self, c):
|
|
return c + ["--memory-swappiness", self.params["memory_swappiness"]]
|
|
|
|
def addparam_mount(self, c):
|
|
for mnt in self.params["mount"]:
|
|
if mnt:
|
|
c += ["--mount", mnt]
|
|
return c
|
|
|
|
def addparam_network(self, c):
|
|
if LooseVersion(self.podman_version) >= LooseVersion("4.0.0"):
|
|
for net in self.params["network"]:
|
|
c += ["--network", net]
|
|
return c
|
|
return c + ["--network", ",".join(self.params["network"])]
|
|
|
|
# Exception for network_aliases and network-alias
|
|
def addparam_network_aliases(self, c):
|
|
for alias in self.params["network_aliases"]:
|
|
c += ["--network-alias", alias]
|
|
return c
|
|
|
|
def addparam_no_hosts(self, c):
|
|
return c + ["--no-hosts=%s" % self.params["no_hosts"]]
|
|
|
|
def addparam_no_healthcheck(self, c):
|
|
if self.params["no_healthcheck"]:
|
|
c += ["--no-healthcheck"]
|
|
return c
|
|
|
|
def addparam_oom_kill_disable(self, c):
|
|
return c + ["--oom-kill-disable=%s" % self.params["oom_kill_disable"]]
|
|
|
|
def addparam_oom_score_adj(self, c):
|
|
return c + ["--oom-score-adj", self.params["oom_score_adj"]]
|
|
|
|
def addparam_os(self, c):
|
|
return c + ["--os", self.params["os"]]
|
|
|
|
def addparam_passwd(self, c):
|
|
if self.params["passwd"]:
|
|
c += ["--passwd"]
|
|
return c
|
|
|
|
def addparam_passwd_entry(self, c):
|
|
return c + ["--passwd-entry", self.params["passwd_entry"]]
|
|
|
|
def addparam_personality(self, c):
|
|
return c + ["--personality", self.params["personality"]]
|
|
|
|
def addparam_pid(self, c):
|
|
return c + ["--pid", self.params["pid"]]
|
|
|
|
def addparam_pid_file(self, c):
|
|
return c + ["--pid-file", self.params["pid_file"]]
|
|
|
|
def addparam_pids_limit(self, c):
|
|
return c + ["--pids-limit", self.params["pids_limit"]]
|
|
|
|
def addparam_platform(self, c):
|
|
return c + ["--platform", self.params["platform"]]
|
|
|
|
def addparam_pod(self, c):
|
|
return c + ["--pod", self.params["pod"]]
|
|
|
|
def addparam_pod_id_file(self, c):
|
|
return c + ["--pod-id-file", self.params["pod_id_file"]]
|
|
|
|
def addparam_preserve_fd(self, c):
|
|
for fd in self.params["preserve_fd"]:
|
|
c += ["--preserve-fd", fd]
|
|
return c
|
|
|
|
def addparam_preserve_fds(self, c):
|
|
return c + ["--preserve-fds", self.params["preserve_fds"]]
|
|
|
|
def addparam_privileged(self, c):
|
|
return c + ["--privileged=%s" % self.params["privileged"]]
|
|
|
|
def addparam_publish(self, c):
|
|
for pub in self.params["publish"]:
|
|
c += ["--publish", pub]
|
|
return c
|
|
|
|
def addparam_publish_all(self, c):
|
|
return c + ["--publish-all=%s" % self.params["publish_all"]]
|
|
|
|
def addparam_pull(self, c):
|
|
return c + ["--pull=%s" % self.params["pull"]]
|
|
|
|
def addparam_rdt_class(self, c):
|
|
return c + ["--rdt-class", self.params["rdt_class"]]
|
|
|
|
def addparam_read_only(self, c):
|
|
return c + ["--read-only=%s" % self.params["read_only"]]
|
|
|
|
def addparam_read_only_tmpfs(self, c):
|
|
return c + ["--read-only-tmpfs=%s" % self.params["read_only_tmpfs"]]
|
|
|
|
def addparam_requires(self, c):
|
|
return c + ["--requires", ",".join(self.params["requires"])]
|
|
|
|
# Exception for restart_policy and restart
|
|
def addparam_restart_policy(self, c):
|
|
return c + ["--restart=%s" % self.params["restart_policy"]]
|
|
|
|
def addparam_retry(self, c):
|
|
return c + ["--retry", self.params["retry"]]
|
|
|
|
def addparam_retry_delay(self, c):
|
|
return c + ["--retry-delay", self.params["retry_delay"]]
|
|
|
|
def addparam_rm(self, c):
|
|
if self.params["rm"]:
|
|
c += ["--rm"]
|
|
return c
|
|
|
|
def addparam_rmi(self, c):
|
|
if self.params["rmi"]:
|
|
c += ["--rmi"]
|
|
return c
|
|
|
|
def addparam_rootfs(self, c):
|
|
return c + ["--rootfs=%s" % self.params["rootfs"]]
|
|
|
|
def addparam_sdnotify(self, c):
|
|
return c + ["--sdnotify=%s" % self.params["sdnotify"]]
|
|
|
|
def addparam_seccomp_policy(self, c):
|
|
return c + ["--seccomp-policy", self.params["seccomp_policy"]]
|
|
|
|
# Exception for secrets and secret
|
|
def addparam_secrets(self, c):
|
|
for secret in self.params["secrets"]:
|
|
c += ["--secret", secret]
|
|
return c
|
|
|
|
def addparam_security_opt(self, c):
|
|
for secopt in self.params["security_opt"]:
|
|
c += ["--security-opt", secopt]
|
|
return c
|
|
|
|
def addparam_shm_size(self, c):
|
|
return c + ["--shm-size", self.params["shm_size"]]
|
|
|
|
def addparam_shm_size_systemd(self, c):
|
|
return c + ["--shm-size-systemd", self.params["shm_size_systemd"]]
|
|
|
|
def addparam_sig_proxy(self, c):
|
|
return c + ["--sig-proxy=%s" % self.params["sig_proxy"]]
|
|
|
|
def addparam_stop_signal(self, c):
|
|
return c + ["--stop-signal", self.params["stop_signal"]]
|
|
|
|
def addparam_stop_timeout(self, c):
|
|
return c + ["--stop-timeout", self.params["stop_timeout"]]
|
|
|
|
def addparam_subgidname(self, c):
|
|
return c + ["--subgidname", self.params["subgidname"]]
|
|
|
|
def addparam_subuidname(self, c):
|
|
return c + ["--subuidname", self.params["subuidname"]]
|
|
|
|
def addparam_sysctl(self, c):
|
|
for sysctl in self.params["sysctl"].items():
|
|
c += [
|
|
"--sysctl",
|
|
b"=".join([to_bytes(k, errors="surrogate_or_strict") for k in sysctl]),
|
|
]
|
|
return c
|
|
|
|
def addparam_systemd(self, c):
|
|
return c + ["--systemd=%s" % str(self.params["systemd"]).lower()]
|
|
|
|
def addparam_timeout(self, c):
|
|
return c + ["--timeout", self.params["timeout"]]
|
|
|
|
# Exception for timezone and tz
|
|
def addparam_timezone(self, c):
|
|
return c + ["--tz=%s" % self.params["timezone"]]
|
|
|
|
def addparam_tls_verify(self, c):
|
|
return c + ["--tls-verify=%s" % self.params["tls_verify"]]
|
|
|
|
def addparam_tmpfs(self, c):
|
|
for tmpfs in self.params["tmpfs"].items():
|
|
c += ["--tmpfs", ":".join(tmpfs)]
|
|
return c
|
|
|
|
def addparam_tty(self, c):
|
|
return c + ["--tty=%s" % self.params["tty"]]
|
|
|
|
def addparam_uidmap(self, c):
|
|
for uidmap in self.params["uidmap"]:
|
|
c += ["--uidmap", uidmap]
|
|
return c
|
|
|
|
def addparam_ulimit(self, c):
|
|
for u in self.params["ulimit"]:
|
|
c += ["--ulimit", u]
|
|
return c
|
|
|
|
def addparam_umask(self, c):
|
|
return c + ["--umask", self.params["umask"]]
|
|
|
|
def addparam_unsetenv(self, c):
|
|
for unsetenv in self.params["unsetenv"]:
|
|
c += ["--unsetenv", unsetenv]
|
|
return c
|
|
|
|
def addparam_unsetenv_all(self, c):
|
|
if self.params["unsetenv_all"]:
|
|
c += ["--unsetenv-all"]
|
|
return c
|
|
|
|
def addparam_user(self, c):
|
|
return c + ["--user", self.params["user"]]
|
|
|
|
def addparam_userns(self, c):
|
|
return c + ["--userns", self.params["userns"]]
|
|
|
|
def addparam_uts(self, c):
|
|
return c + ["--uts", self.params["uts"]]
|
|
|
|
def addparam_variant(self, c):
|
|
return c + ["--variant", self.params["variant"]]
|
|
|
|
def addparam_volume(self, c):
|
|
for vol in self.params["volume"]:
|
|
if vol:
|
|
c += ["--volume", vol]
|
|
return c
|
|
|
|
def addparam_volumes_from(self, c):
|
|
for vol in self.params["volumes_from"]:
|
|
c += ["--volumes-from", vol]
|
|
return c
|
|
|
|
def addparam_workdir(self, c):
|
|
return c + ["--workdir", self.params["workdir"]]
|
|
|
|
# Add your own args for podman command
|
|
def addparam_cmd_args(self, c):
|
|
return c + self.params["cmd_args"]
|
|
|
|
|
|
class PodmanDefaults:
|
|
def __init__(self, image_info, podman_version):
|
|
self.version = podman_version
|
|
self.image_info = image_info
|
|
self.defaults = {
|
|
"detach": True,
|
|
"log_level": "error",
|
|
"tty": False,
|
|
}
|
|
|
|
def default_dict(self):
|
|
# make here any changes to self.defaults related to podman version
|
|
# https://github.com/containers/libpod/pull/5669
|
|
if LooseVersion(self.version) >= LooseVersion("1.8.0") and LooseVersion(
|
|
self.version
|
|
) < LooseVersion("1.9.0"):
|
|
self.defaults["cpu_shares"] = 1024
|
|
if LooseVersion(self.version) >= LooseVersion("3.0.0"):
|
|
self.defaults["log_level"] = "warning"
|
|
return self.defaults
|
|
|
|
|
|
class PodmanContainerDiff:
|
|
def __init__(self, module, module_params, info, image_info, podman_version):
|
|
self.module = module
|
|
self.module_params = module_params
|
|
self.version = podman_version
|
|
self.default_dict = None
|
|
self.info = lower_keys(info)
|
|
self.image_info = lower_keys(image_info)
|
|
self.params = self.defaultize()
|
|
self.diff = {"before": {}, "after": {}}
|
|
self.non_idempotent = {}
|
|
|
|
def defaultize(self):
|
|
params_with_defaults = {}
|
|
self.default_dict = PodmanDefaults(self.image_info, self.version).default_dict()
|
|
for p in self.module_params:
|
|
if self.module_params[p] is None and p in self.default_dict:
|
|
params_with_defaults[p] = self.default_dict[p]
|
|
else:
|
|
params_with_defaults[p] = self.module_params[p]
|
|
return params_with_defaults
|
|
|
|
def _diff_update_and_compare(self, param_name, before, after):
|
|
if before != after:
|
|
self.diff["before"].update({param_name: before})
|
|
self.diff["after"].update({param_name: after})
|
|
return True
|
|
return False
|
|
|
|
def _diff_generic(self, module_arg, cmd_arg, boolean_type=False):
|
|
"""
|
|
Generic diff function for module arguments from CreateCommand
|
|
in Podman inspection output.
|
|
|
|
Args:
|
|
module_arg (str): module argument name
|
|
cmd_arg (str): command line argument name
|
|
boolean_type (bool): if True, then argument is boolean type
|
|
|
|
Returns:
|
|
bool: True if there is a difference, False otherwise
|
|
|
|
"""
|
|
info_config = self.info["config"]
|
|
before, after = diff_generic(
|
|
self.params, info_config, module_arg, cmd_arg, boolean_type
|
|
)
|
|
return self._diff_update_and_compare(module_arg, before, after)
|
|
|
|
def diffparam_annotation(self):
|
|
before = self.info["config"]["annotations"] or {}
|
|
after = before.copy()
|
|
if self.module_params["annotation"] is not None:
|
|
after.update(self.params["annotation"])
|
|
return self._diff_update_and_compare("annotation", before, after)
|
|
|
|
def diffparam_arch(self):
|
|
return self._diff_generic("arch", "--arch")
|
|
|
|
def diffparam_authfile(self):
|
|
return self._diff_generic("authfile", "--authfile")
|
|
|
|
def diffparam_blkio_weight(self):
|
|
return self._diff_generic("blkio_weight", "--blkio-weight")
|
|
|
|
def diffparam_blkio_weight_device(self):
|
|
return self._diff_generic("blkio_weight_device", "--blkio-weight-device")
|
|
|
|
def diffparam_cap_add(self):
|
|
before = self.info["effectivecaps"] or []
|
|
before = [i.lower() for i in before]
|
|
after = []
|
|
if self.module_params["cap_add"] is not None:
|
|
for cap in self.module_params["cap_add"]:
|
|
cap = cap.lower()
|
|
cap = cap if cap.startswith("cap_") else "cap_" + cap
|
|
after.append(cap)
|
|
after += before
|
|
before, after = sorted(list(set(before))), sorted(list(set(after)))
|
|
return self._diff_update_and_compare("cap_add", before, after)
|
|
|
|
def diffparam_cap_drop(self):
|
|
before = self.info["effectivecaps"] or []
|
|
before = [i.lower() for i in before]
|
|
after = before[:]
|
|
if self.module_params["cap_drop"] is not None:
|
|
for cap in self.module_params["cap_drop"]:
|
|
cap = cap.lower()
|
|
cap = cap if cap.startswith("cap_") else "cap_" + cap
|
|
if cap in after:
|
|
after.remove(cap)
|
|
before, after = sorted(list(set(before))), sorted(list(set(after)))
|
|
return self._diff_update_and_compare("cap_drop", before, after)
|
|
|
|
def diffparam_cgroup_conf(self):
|
|
return self._diff_generic("cgroup_conf", "--cgroup-conf")
|
|
|
|
def diffparam_cgroup_parent(self):
|
|
return self._diff_generic("cgroup_parent", "--cgroup-parent")
|
|
|
|
def diffparam_cgroupns(self):
|
|
return self._diff_generic("cgroupns", "--cgroupns")
|
|
|
|
# Disabling idemotency check for cgroups as it's added by systemd generator
|
|
# https://github.com/containers/ansible-podman-collections/issues/775
|
|
# def diffparam_cgroups(self):
|
|
# return self._diff_generic('cgroups', '--cgroups')
|
|
|
|
def diffparam_chrootdirs(self):
|
|
return self._diff_generic("chrootdirs", "--chrootdirs")
|
|
|
|
# Disabling idemotency check for cidfile as it's added by systemd generator
|
|
# https://github.com/containers/ansible-podman-collections/issues/775
|
|
# def diffparam_cidfile(self):
|
|
# return self._diff_generic('cidfile', '--cidfile')
|
|
|
|
def diffparam_command(self):
|
|
def _join_quotes(com_list):
|
|
result = []
|
|
buffer = []
|
|
in_quotes = False
|
|
|
|
for item in com_list:
|
|
if item.startswith('"') and not in_quotes:
|
|
buffer.append(item)
|
|
in_quotes = True
|
|
elif item.endswith('"') and in_quotes:
|
|
buffer.append(item)
|
|
result.append(" ".join(buffer).strip('"'))
|
|
buffer = []
|
|
in_quotes = False
|
|
elif in_quotes:
|
|
buffer.append(item)
|
|
else:
|
|
result.append(item)
|
|
if in_quotes:
|
|
result.extend(buffer)
|
|
|
|
return result
|
|
|
|
# TODO(sshnaidm): to inspect image to get the default command
|
|
if self.module_params["command"] is not None:
|
|
before = self.info["config"]["cmd"]
|
|
after = self.params["command"]
|
|
if before:
|
|
before = _join_quotes(before)
|
|
if isinstance(after, list):
|
|
after = [str(i) for i in after]
|
|
if isinstance(after, str):
|
|
after = shlex.split(after)
|
|
return self._diff_update_and_compare("command", before, after)
|
|
return False
|
|
|
|
def diffparam_conmon_pidfile(self):
|
|
return self._diff_generic("conmon_pidfile", "--conmon-pidfile")
|
|
|
|
def diffparam_cpu_period(self):
|
|
return self._diff_generic("cpu_period", "--cpu-period")
|
|
|
|
def diffparam_cpu_quota(self):
|
|
return self._diff_generic("cpu_quota", "--cpu-quota")
|
|
|
|
def diffparam_cpu_rt_period(self):
|
|
return self._diff_generic("cpu_rt_period", "--cpu-rt-period")
|
|
|
|
def diffparam_cpu_rt_runtime(self):
|
|
return self._diff_generic("cpu_rt_runtime", "--cpu-rt-runtime")
|
|
|
|
def diffparam_cpu_shares(self):
|
|
return self._diff_generic("cpu_shares", "--cpu-shares")
|
|
|
|
def diffparam_cpus(self):
|
|
return self._diff_generic("cpus", "--cpus")
|
|
|
|
def diffparam_cpuset_cpus(self):
|
|
return self._diff_generic("cpuset_cpus", "--cpuset-cpus")
|
|
|
|
def diffparam_cpuset_mems(self):
|
|
return self._diff_generic("cpuset_mems", "--cpuset-mems")
|
|
|
|
def diffparam_decryption_key(self):
|
|
return self._diff_generic("decryption_key", "--decryption-key")
|
|
|
|
def diffparam_device(self):
|
|
return self._diff_generic("device", "--device")
|
|
|
|
def diffparam_device_cgroup_rule(self):
|
|
return self._diff_generic("device_cgroup_rule", "--device-cgroup-rule")
|
|
|
|
def diffparam_device_read_bps(self):
|
|
return self._diff_generic("device_read_bps", "--device-read-bps")
|
|
|
|
def diffparam_device_read_iops(self):
|
|
return self._diff_generic("device_read_iops", "--device-read-iops")
|
|
|
|
def diffparam_device_write_bps(self):
|
|
return self._diff_generic("device_write_bps", "--device-write-bps")
|
|
|
|
def diffparam_device_write_iops(self):
|
|
return self._diff_generic("device_write_iops", "--device-write-iops")
|
|
|
|
def diffparam_dns(self):
|
|
return self._diff_generic("dns", "--dns")
|
|
|
|
def diffparam_dns_option(self):
|
|
return self._diff_generic("dns_option", "--dns-option")
|
|
|
|
def diffparam_dns_search(self):
|
|
return self._diff_generic("dns_search", "--dns-search")
|
|
|
|
def diffparam_env(self):
|
|
return self._diff_generic("env", "--env")
|
|
|
|
def diffparam_env_file(self):
|
|
return self._diff_generic("env_file", "--env-file")
|
|
|
|
def diffparam_env_merge(self):
|
|
return self._diff_generic("env_merge", "--env-merge")
|
|
|
|
def diffparam_env_host(self):
|
|
return self._diff_generic("env_host", "--env-host")
|
|
|
|
def diffparam_etc_hosts(self):
|
|
if self.info["hostconfig"]["extrahosts"]:
|
|
before = dict(
|
|
[i.split(":", 1) for i in self.info["hostconfig"]["extrahosts"]]
|
|
)
|
|
else:
|
|
before = {}
|
|
after = self.params["etc_hosts"] or {}
|
|
return self._diff_update_and_compare("etc_hosts", before, after)
|
|
|
|
def diffparam_expose(self):
|
|
return self._diff_generic("expose", "--expose")
|
|
|
|
def diffparam_gidmap(self):
|
|
return self._diff_generic("gidmap", "--gidmap")
|
|
|
|
def diffparam_gpus(self):
|
|
return self._diff_generic("gpus", "--gpus")
|
|
|
|
def diffparam_group_add(self):
|
|
return self._diff_generic("group_add", "--group-add")
|
|
|
|
def diffparam_group_entry(self):
|
|
return self._diff_generic("group_entry", "--group-entry")
|
|
|
|
# Healthcheck is only defined in container config if a healthcheck
|
|
# was configured; otherwise the config key isn't part of the config.
|
|
def diffparam_healthcheck(self):
|
|
before = ""
|
|
if "healthcheck" in self.info["config"]:
|
|
# the "test" key is a list of 2 items where the first one is
|
|
# "CMD-SHELL" and the second one is the actual healthcheck command.
|
|
if len(self.info["config"]["healthcheck"]["test"]) > 1:
|
|
before = self.info["config"]["healthcheck"]["test"][1]
|
|
after = self.params["healthcheck"] or before
|
|
return self._diff_update_and_compare("healthcheck", before, after)
|
|
|
|
def diffparam_healthcheck_failure_action(self):
|
|
if "healthcheckonfailureaction" in self.info["config"]:
|
|
before = self.info["config"]["healthcheckonfailureaction"]
|
|
else:
|
|
before = ""
|
|
after = self.params["healthcheck_failure_action"] or before
|
|
return self._diff_update_and_compare(
|
|
"healthcheckonfailureaction", before, after
|
|
)
|
|
|
|
def diffparam_healthcheck_interval(self):
|
|
return self._diff_generic("healthcheck_interval", "--healthcheck-interval")
|
|
|
|
def diffparam_healthcheck_retries(self):
|
|
return self._diff_generic("healthcheck_retries", "--healthcheck-retries")
|
|
|
|
def diffparam_healthcheck_start_period(self):
|
|
return self._diff_generic(
|
|
"healthcheck_start_period", "--healthcheck-start-period"
|
|
)
|
|
|
|
def diffparam_health_startup_cmd(self):
|
|
return self._diff_generic("health_startup_cmd", "--health-startup-cmd")
|
|
|
|
def diffparam_health_startup_interval(self):
|
|
return self._diff_generic(
|
|
"health_startup_interval", "--health-startup-interval"
|
|
)
|
|
|
|
def diffparam_health_startup_retries(self):
|
|
return self._diff_generic("health_startup_retries", "--health-startup-retries")
|
|
|
|
def diffparam_health_startup_success(self):
|
|
return self._diff_generic("health_startup_success", "--health-startup-success")
|
|
|
|
def diffparam_health_startup_timeout(self):
|
|
return self._diff_generic("health_startup_timeout", "--health-startup-timeout")
|
|
|
|
def diffparam_healthcheck_timeout(self):
|
|
return self._diff_generic("healthcheck_timeout", "--healthcheck-timeout")
|
|
|
|
def diffparam_hooks_dir(self):
|
|
return self._diff_generic("hooks_dir", "--hooks-dir")
|
|
|
|
def diffparam_hostname(self):
|
|
return self._diff_generic("hostname", "--hostname")
|
|
|
|
def diffparam_hostuser(self):
|
|
return self._diff_generic("hostuser", "--hostuser")
|
|
|
|
def diffparam_http_proxy(self):
|
|
return self._diff_generic("http_proxy", "--http-proxy")
|
|
|
|
def diffparam_image(self):
|
|
before_id = self.info["image"] or self.info["rootfs"]
|
|
after_id = self.image_info["id"]
|
|
if before_id == after_id:
|
|
return self._diff_update_and_compare("image", before_id, after_id)
|
|
is_rootfs = self.info["rootfs"] != "" or self.params["rootfs"]
|
|
before = self.info["config"]["image"] or before_id
|
|
after = self.params["image"]
|
|
mode = self.params["image_strict"] or is_rootfs
|
|
if mode is None or not mode:
|
|
# In a idempotency 'lite mode' assume all images from different registries are the same
|
|
before = before.replace(":latest", "")
|
|
after = after.replace(":latest", "")
|
|
before = before.split("/")[-1]
|
|
after = after.split("/")[-1]
|
|
else:
|
|
return self._diff_update_and_compare("image", before_id, after_id)
|
|
return self._diff_update_and_compare("image", before, after)
|
|
|
|
def diffparam_image_volume(self):
|
|
return self._diff_generic("image_volume", "--image-volume")
|
|
|
|
def diffparam_init(self):
|
|
return self._diff_generic("init", "--init", boolean_type=True)
|
|
|
|
def diffparam_init_ctr(self):
|
|
return self._diff_generic("init_ctr", "--init-ctr")
|
|
|
|
def diffparam_init_path(self):
|
|
return self._diff_generic("init_path", "--init-path")
|
|
|
|
def diffparam_interactive(self):
|
|
return self._diff_generic("interactive", "--interactive")
|
|
|
|
def diffparam_ip(self):
|
|
return self._diff_generic("ip", "--ip")
|
|
|
|
def diffparam_ip6(self):
|
|
return self._diff_generic("ip6", "--ip6")
|
|
|
|
def diffparam_ipc(self):
|
|
return self._diff_generic("ipc", "--ipc")
|
|
|
|
def diffparam_label(self):
|
|
before = self.info["config"]["labels"] or {}
|
|
after = self.image_info.get("labels") or {}
|
|
if self.params["label"]:
|
|
after.update(
|
|
{str(k).lower(): str(v) for k, v in self.params["label"].items()}
|
|
)
|
|
# Strip out labels that are coming from systemd files
|
|
# https://github.com/containers/ansible-podman-collections/issues/276
|
|
if "podman_systemd_unit" in before:
|
|
after.pop("podman_systemd_unit", None)
|
|
before.pop("podman_systemd_unit", None)
|
|
return self._diff_update_and_compare("label", before, after)
|
|
|
|
def diffparam_label_file(self):
|
|
return self._diff_generic("label_file", "--label-file")
|
|
|
|
def diffparam_log_driver(self):
|
|
return self._diff_generic("log_driver", "--log-driver")
|
|
|
|
def diffparam_log_opt(self):
|
|
return self._diff_generic("log_opt", "--log-opt")
|
|
|
|
def diffparam_mac_address(self):
|
|
return self._diff_generic("mac_address", "--mac-address")
|
|
|
|
def diffparam_memory(self):
|
|
return self._diff_generic("memory", "--memory")
|
|
|
|
def diffparam_memory_reservation(self):
|
|
return self._diff_generic("memory_reservation", "--memory-reservation")
|
|
|
|
def diffparam_memory_swap(self):
|
|
return self._diff_generic("memory_swap", "--memory-swap")
|
|
|
|
def diffparam_memory_swappiness(self):
|
|
return self._diff_generic("memory_swappiness", "--memory-swappiness")
|
|
|
|
def diffparam_mount(self):
|
|
return self._diff_generic("mount", "--mount")
|
|
|
|
def diffparam_network(self):
|
|
return self._diff_generic("network", "--network")
|
|
|
|
def diffparam_network_aliases(self):
|
|
return self._diff_generic("network_aliases", "--network-alias")
|
|
|
|
def diffparam_no_healthcheck(self):
|
|
return self._diff_generic(
|
|
"no_healthcheck", "--no-healthcheck", boolean_type=True
|
|
)
|
|
|
|
def diffparam_no_hosts(self):
|
|
return self._diff_generic("no_hosts", "--no-hosts")
|
|
|
|
def diffparam_oom_kill_disable(self):
|
|
return self._diff_generic("oom_kill_disable", "--oom-kill-disable")
|
|
|
|
def diffparam_oom_score_adj(self):
|
|
return self._diff_generic("oom_score_adj", "--oom-score-adj")
|
|
|
|
def diffparam_os(self):
|
|
return self._diff_generic("os", "--os")
|
|
|
|
def diffparam_passwd(self):
|
|
return self._diff_generic("passwd", "--passwd", boolean_type=True)
|
|
|
|
def diffparam_passwd_entry(self):
|
|
return self._diff_generic("passwd_entry", "--passwd-entry")
|
|
|
|
def diffparam_personality(self):
|
|
return self._diff_generic("personality", "--personality")
|
|
|
|
def diffparam_pid(self):
|
|
return self._diff_generic("pid", "--pid")
|
|
|
|
def diffparam_pid_file(self):
|
|
return self._diff_generic("pid_file", "--pid-file")
|
|
|
|
def diffparam_pids_limit(self):
|
|
return self._diff_generic("pids_limit", "--pids-limit")
|
|
|
|
def diffparam_platform(self):
|
|
return self._diff_generic("platform", "--platform")
|
|
|
|
# def diffparam_pod(self):
|
|
# return self._diff_generic('pod', '--pod')
|
|
|
|
# https://github.com/containers/ansible-podman-collections/issues/828
|
|
# def diffparam_pod_id_file(self):
|
|
# return self._diff_generic('pod_id_file', '--pod-id-file')
|
|
|
|
def diffparam_privileged(self):
|
|
return self._diff_generic("privileged", "--privileged")
|
|
|
|
def diffparam_publish(self):
|
|
return self._diff_generic("publish", "--publish")
|
|
|
|
def diffparam_publish_all(self):
|
|
return self._diff_generic("publish_all", "--publish-all")
|
|
|
|
def diffparam_pull(self):
|
|
return self._diff_generic("pull", "--pull")
|
|
|
|
def diffparam_rdt_class(self):
|
|
return self._diff_generic("rdt_class", "--rdt-class")
|
|
|
|
def diffparam_read_only(self):
|
|
return self._diff_generic("read_only", "--read-only")
|
|
|
|
def diffparam_read_only_tmpfs(self):
|
|
return self._diff_generic("read_only_tmpfs", "--read-only-tmpfs")
|
|
|
|
def diffparam_requires(self):
|
|
return self._diff_generic("requires", "--requires")
|
|
|
|
def diffparam_restart_policy(self):
|
|
return self._diff_generic("restart_policy", "--restart")
|
|
|
|
def diffparam_retry(self):
|
|
return self._diff_generic("retry", "--retry")
|
|
|
|
def diffparam_retry_delay(self):
|
|
return self._diff_generic("retry_delay", "--retry-delay")
|
|
|
|
def diffparam_rootfs(self):
|
|
return self._diff_generic("rootfs", "--rootfs")
|
|
|
|
# Disabling idemotency check for sdnotify as it's added by systemd generator
|
|
# https://github.com/containers/ansible-podman-collections/issues/775
|
|
# def diffparam_sdnotify(self):
|
|
# return self._diff_generic('sdnotify', '--sdnotify')
|
|
|
|
def diffparam_rm(self):
|
|
before = self.info["hostconfig"]["autoremove"]
|
|
after = self.params["rm"]
|
|
if after is None:
|
|
return self._diff_update_and_compare("rm", "", "")
|
|
return self._diff_update_and_compare("rm", before, after)
|
|
|
|
def diffparam_rmi(self):
|
|
return self._diff_generic("rmi", "--rmi", boolean_type=True)
|
|
|
|
def diffparam_seccomp_policy(self):
|
|
return self._diff_generic("seccomp_policy", "--seccomp-policy")
|
|
|
|
def diffparam_secrets(self):
|
|
return self._diff_generic("secrets", "--secret")
|
|
|
|
def diffparam_security_opt(self):
|
|
return self._diff_generic("security_opt", "--security-opt")
|
|
|
|
def diffparam_shm_size(self):
|
|
return self._diff_generic("shm_size", "--shm-size")
|
|
|
|
def diffparam_shm_size_systemd(self):
|
|
return self._diff_generic("shm_size_systemd", "--shm-size-systemd")
|
|
|
|
def diffparam_stop_signal(self):
|
|
return self._diff_generic("stop_signal", "--stop-signal")
|
|
|
|
def diffparam_stop_timeout(self):
|
|
return self._diff_generic("stop_timeout", "--stop-timeout")
|
|
|
|
def diffparam_subgidname(self):
|
|
return self._diff_generic("subgidname", "--subgidname")
|
|
|
|
def diffparam_subuidname(self):
|
|
return self._diff_generic("subuidname", "--subuidname")
|
|
|
|
def diffparam_sysctl(self):
|
|
return self._diff_generic("sysctl", "--sysctl")
|
|
|
|
def diffparam_systemd(self):
|
|
if self.params["systemd"] is not None:
|
|
self.params["systemd"] = str(self.params["systemd"]).lower()
|
|
return self._diff_generic("systemd", "--systemd")
|
|
|
|
def diffparam_timeout(self):
|
|
return self._diff_generic("timeout", "--timeout")
|
|
|
|
def diffparam_timezone(self):
|
|
return self._diff_generic("timezone", "--tz")
|
|
|
|
def diffparam_tls_verify(self):
|
|
return self._diff_generic("tls_verify", "--tls-verify")
|
|
|
|
def diffparam_tty(self):
|
|
before = self.info["config"]["tty"]
|
|
after = self.params["tty"]
|
|
return self._diff_update_and_compare("tty", before, after)
|
|
|
|
def diffparam_tmpfs(self):
|
|
before = createcommand("--tmpfs", self.info["config"])
|
|
if before == []:
|
|
before = None
|
|
after = self.params["tmpfs"]
|
|
if before is None and after is None:
|
|
return self._diff_update_and_compare("tmpfs", before, after)
|
|
if after is not None:
|
|
after = ",".join(
|
|
sorted(
|
|
[
|
|
str(k).lower() + ":" + str(v).lower()
|
|
for k, v in after.items()
|
|
if v is not None
|
|
]
|
|
)
|
|
)
|
|
if before:
|
|
before = ",".join(sorted([j.lower() for j in before]))
|
|
else:
|
|
before = ""
|
|
return self._diff_update_and_compare("tmpfs", before, after)
|
|
|
|
def diffparam_uidmap(self):
|
|
return self._diff_generic("uidmap", "--uidmap")
|
|
|
|
def diffparam_ulimit(self):
|
|
return self._diff_generic("ulimit", "--ulimit")
|
|
|
|
def diffparam_umask(self):
|
|
return self._diff_generic("umask", "--umask")
|
|
|
|
def diffparam_unsetenv(self):
|
|
return self._diff_generic("unsetenv", "--unsetenv")
|
|
|
|
def diffparam_unsetenv_all(self):
|
|
return self._diff_generic("unsetenv_all", "--unsetenv-all", boolean_type=True)
|
|
|
|
def diffparam_user(self):
|
|
return self._diff_generic("user", "--user")
|
|
|
|
def diffparam_userns(self):
|
|
return self._diff_generic("userns", "--userns")
|
|
|
|
def diffparam_uts(self):
|
|
return self._diff_generic("uts", "--uts")
|
|
|
|
def diffparam_variant(self):
|
|
return self._diff_generic("variant", "--variant")
|
|
|
|
def diffparam_volume(self):
|
|
def clean_volume(x):
|
|
"""Remove trailing and double slashes from volumes."""
|
|
if not x.rstrip("/"):
|
|
return "/"
|
|
return x.replace("//", "/").rstrip("/")
|
|
|
|
before = createcommand("--volume", self.info["config"])
|
|
if before == []:
|
|
before = None
|
|
after = self.params["volume"]
|
|
if after is not None:
|
|
after = [
|
|
":".join([clean_volume(i) for i in v.split(":")[:3]])
|
|
for v in self.params["volume"]
|
|
]
|
|
if before is not None:
|
|
before = [
|
|
":".join([clean_volume(i) for i in v.split(":")[:3]]) for v in before
|
|
]
|
|
if before is None and after is None:
|
|
return self._diff_update_and_compare("volume", before, after)
|
|
if after is not None:
|
|
after = ",".join(sorted([str(i).lower() for i in after]))
|
|
if before:
|
|
before = ",".join(sorted([str(i).lower() for i in before]))
|
|
return self._diff_update_and_compare("volume", before, after)
|
|
|
|
def diffparam_volumes_from(self):
|
|
return self._diff_generic("volumes_from", "--volumes-from")
|
|
|
|
def diffparam_workdir(self):
|
|
return self._diff_generic("workdir", "--workdir")
|
|
|
|
def is_different(self):
|
|
diff_func_list = [
|
|
func
|
|
for func in dir(self)
|
|
if callable(getattr(self, func)) and func.startswith("diffparam")
|
|
]
|
|
fail_fast = not bool(self.module._diff)
|
|
different = False
|
|
for func_name in diff_func_list:
|
|
dff_func = getattr(self, func_name)
|
|
if dff_func():
|
|
if fail_fast:
|
|
return True
|
|
different = True
|
|
# Check non idempotent parameters
|
|
for p in self.non_idempotent:
|
|
if self.module_params[p] is not None and self.module_params[p] not in [
|
|
{},
|
|
[],
|
|
"",
|
|
]:
|
|
different = True
|
|
return different
|
|
|
|
|
|
def ensure_image_exists(module, image, module_params):
|
|
"""If image is passed, ensure it exists, if not - pull it or fail.
|
|
|
|
Arguments:
|
|
module {obj} -- ansible module object
|
|
image {str} -- name of image
|
|
|
|
Returns:
|
|
list -- list of image actions - if it pulled or nothing was done
|
|
"""
|
|
image_actions = []
|
|
module_exec = module_params["executable"]
|
|
is_rootfs = module_params["rootfs"]
|
|
|
|
if is_rootfs:
|
|
if not os.path.exists(image) or not os.path.isdir(image):
|
|
module.fail_json(msg="Image rootfs doesn't exist %s" % image)
|
|
return image_actions
|
|
if not image:
|
|
return image_actions
|
|
image_exists_cmd = [module_exec, "image", "exists", image]
|
|
rc, out, err = module.run_command(image_exists_cmd)
|
|
if rc == 0:
|
|
return image_actions
|
|
image_pull_cmd = [module_exec, "image", "pull", image]
|
|
if module_params["tls_verify"] is False:
|
|
image_pull_cmd.append("--tls-verify=false")
|
|
if module_params["authfile"]:
|
|
image_pull_cmd.extend(["--authfile", module_params["authfile"]])
|
|
if module_params["arch"]:
|
|
image_pull_cmd.append("--arch=%s" % module_params["arch"])
|
|
if module_params["decryption_key"]:
|
|
image_pull_cmd.append("--decryption-key=%s" % module_params["decryption_key"])
|
|
if module_params["platform"]:
|
|
image_pull_cmd.append("--platform=%s" % module_params["platform"])
|
|
if module_params["os"]:
|
|
image_pull_cmd.append("--os=%s" % module_params["os"])
|
|
if module_params["variant"]:
|
|
image_pull_cmd.append("--variant=%s" % module_params["variant"])
|
|
if module_params.get("debug"):
|
|
module.log("PODMAN-CONTAINER-DEBUG: %s" % " ".join(image_pull_cmd))
|
|
rc, out, err = module.run_command(image_pull_cmd)
|
|
if rc != 0:
|
|
module.fail_json(msg="Can't pull image %s" % image, stdout=out, stderr=err)
|
|
image_actions.append("pulled image %s" % image)
|
|
return image_actions
|
|
|
|
|
|
class PodmanContainer:
|
|
"""Perform container tasks.
|
|
|
|
Manages podman container, inspects it and checks its current state
|
|
"""
|
|
|
|
def __init__(self, module, name, module_params):
|
|
"""Initialize PodmanContainer class.
|
|
|
|
Arguments:
|
|
module {obj} -- ansible module object
|
|
name {str} -- name of container
|
|
"""
|
|
|
|
self.module = module
|
|
self.module_params = module_params
|
|
self.name = name
|
|
self.stdout, self.stderr = "", ""
|
|
self.info = self.get_info()
|
|
self.version = self._get_podman_version()
|
|
self.diff = {}
|
|
self.actions = []
|
|
|
|
@property
|
|
def exists(self):
|
|
"""Check if container exists."""
|
|
return bool(self.info != {})
|
|
|
|
@property
|
|
def different(self):
|
|
"""Check if container is different."""
|
|
diffcheck = PodmanContainerDiff(
|
|
self.module,
|
|
self.module_params,
|
|
self.info,
|
|
self.get_image_info(),
|
|
self.version,
|
|
)
|
|
is_different = diffcheck.is_different()
|
|
diffs = diffcheck.diff
|
|
if self.module._diff and is_different and diffs["before"] and diffs["after"]:
|
|
self.diff["before"] = (
|
|
"\n".join(
|
|
["%s - %s" % (k, v) for k, v in sorted(diffs["before"].items())]
|
|
)
|
|
+ "\n"
|
|
)
|
|
self.diff["after"] = (
|
|
"\n".join(
|
|
["%s - %s" % (k, v) for k, v in sorted(diffs["after"].items())]
|
|
)
|
|
+ "\n"
|
|
)
|
|
return is_different
|
|
|
|
@property
|
|
def running(self):
|
|
"""Return True if container is running now."""
|
|
return self.exists and self.info["State"]["Running"]
|
|
|
|
@property
|
|
def stopped(self):
|
|
"""Return True if container exists and is not running now."""
|
|
return self.exists and not self.info["State"]["Running"]
|
|
|
|
def get_info(self):
|
|
"""Inspect container and gather info about it."""
|
|
# pylint: disable=unused-variable
|
|
rc, out, err = self.module.run_command(
|
|
[self.module_params["executable"], b"container", b"inspect", self.name]
|
|
)
|
|
return json.loads(out)[0] if rc == 0 else {}
|
|
|
|
def get_image_info(self):
|
|
"""Inspect container image and gather info about it."""
|
|
# pylint: disable=unused-variable
|
|
is_rootfs = self.module_params["rootfs"]
|
|
if is_rootfs:
|
|
return {"Id": self.module_params["image"]}
|
|
rc, out, err = self.module.run_command(
|
|
[
|
|
self.module_params["executable"],
|
|
b"image",
|
|
b"inspect",
|
|
self.module_params["image"].replace("docker://", ""),
|
|
]
|
|
)
|
|
self.module.log(
|
|
"PODMAN-CONTAINER-DEBUG: %s: %s" % (out, self.module_params["image"])
|
|
)
|
|
return json.loads(out)[0] if rc == 0 else {}
|
|
|
|
def _get_podman_version(self):
|
|
# pylint: disable=unused-variable
|
|
rc, out, err = self.module.run_command(
|
|
[self.module_params["executable"], b"--version"]
|
|
)
|
|
if rc != 0 or not out or "version" not in out:
|
|
self.module.fail_json(
|
|
msg="%s run failed!" % self.module_params["executable"]
|
|
)
|
|
return out.split("version")[1].strip()
|
|
|
|
def _perform_action(self, action):
|
|
"""Perform action with container.
|
|
|
|
Arguments:
|
|
action {str} -- action to perform - start, create, stop, run,
|
|
delete, restart
|
|
"""
|
|
b_command = PodmanModuleParams(
|
|
action,
|
|
self.module_params,
|
|
self.version,
|
|
self.module,
|
|
).construct_command_from_params()
|
|
full_cmd = " ".join(
|
|
[self.module_params["executable"]] + [to_native(i) for i in b_command]
|
|
)
|
|
self.actions.append(full_cmd)
|
|
if self.module.check_mode:
|
|
self.module.log("PODMAN-CONTAINER-DEBUG (check_mode): %s" % full_cmd)
|
|
else:
|
|
rc, out, err = self.module.run_command(
|
|
[self.module_params["executable"], b"container"] + b_command,
|
|
expand_user_and_vars=False,
|
|
)
|
|
self.module.log("PODMAN-CONTAINER-DEBUG: %s" % full_cmd)
|
|
if self.module_params["debug"]:
|
|
self.module.log("PODMAN-CONTAINER-DEBUG STDOUT: %s" % out)
|
|
self.module.log("PODMAN-CONTAINER-DEBUG STDERR: %s" % err)
|
|
self.module.log("PODMAN-CONTAINER-DEBUG RC: %s" % rc)
|
|
self.stdout = out
|
|
self.stderr = err
|
|
if rc != 0:
|
|
self.module.fail_json(
|
|
msg="Container %s exited with code %s when %sed"
|
|
% (self.name, rc, action),
|
|
stdout=out,
|
|
stderr=err,
|
|
)
|
|
|
|
def run(self):
|
|
"""Run the container."""
|
|
self._perform_action("run")
|
|
|
|
def delete(self):
|
|
"""Delete the container."""
|
|
self._perform_action("delete")
|
|
|
|
def stop(self):
|
|
"""Stop the container."""
|
|
self._perform_action("stop")
|
|
|
|
def start(self):
|
|
"""Start the container."""
|
|
self._perform_action("start")
|
|
|
|
def restart(self):
|
|
"""Restart the container."""
|
|
self._perform_action("restart")
|
|
|
|
def create(self):
|
|
"""Create the container."""
|
|
self._perform_action("create")
|
|
|
|
def recreate(self):
|
|
"""Recreate the container."""
|
|
if self.running:
|
|
self.stop()
|
|
if not self.info["HostConfig"]["AutoRemove"]:
|
|
self.delete()
|
|
self.create()
|
|
|
|
def recreate_run(self):
|
|
"""Recreate and run the container."""
|
|
if self.running:
|
|
self.stop()
|
|
if not self.info["HostConfig"]["AutoRemove"]:
|
|
self.delete()
|
|
self.run()
|
|
|
|
|
|
class PodmanManager:
|
|
"""Module manager class.
|
|
|
|
Defines according to parameters what actions should be applied to container
|
|
"""
|
|
|
|
def __init__(self, module, params):
|
|
"""Initialize PodmanManager class.
|
|
|
|
Arguments:
|
|
module {obj} -- ansible module object
|
|
"""
|
|
|
|
self.module = module
|
|
self.results = {
|
|
"changed": False,
|
|
"actions": [],
|
|
"container": {},
|
|
}
|
|
self.module_params = params
|
|
self.name = self.module_params["name"]
|
|
self.executable = self.module.get_bin_path(
|
|
self.module_params["executable"], required=True
|
|
)
|
|
self.image = self.module_params["image"]
|
|
self.state = self.module_params["state"]
|
|
disable_image_pull = (
|
|
self.state in ("quadlet", "absent") or self.module_params["pull"] == "never"
|
|
)
|
|
image_actions = (
|
|
ensure_image_exists(self.module, self.image, self.module_params)
|
|
if not disable_image_pull
|
|
else []
|
|
)
|
|
self.results["actions"] += image_actions
|
|
|
|
self.restart = self.module_params["force_restart"]
|
|
self.recreate = self.module_params["recreate"]
|
|
|
|
if self.module_params["generate_systemd"].get("new"):
|
|
self.module_params["rm"] = True
|
|
|
|
self.container = PodmanContainer(self.module, self.name, self.module_params)
|
|
|
|
def update_container_result(self, changed=True):
|
|
"""Inspect the current container, update results with last info, exit.
|
|
|
|
Keyword Arguments:
|
|
changed {bool} -- whether any action was performed
|
|
(default: {True})
|
|
"""
|
|
facts = self.container.get_info() if changed else self.container.info
|
|
out, err = self.container.stdout, self.container.stderr
|
|
self.results.update(
|
|
{
|
|
"changed": changed,
|
|
"container": facts,
|
|
"podman_actions": self.container.actions,
|
|
},
|
|
stdout=out,
|
|
stderr=err,
|
|
)
|
|
if self.container.diff:
|
|
self.results.update({"diff": self.container.diff})
|
|
if self.module.params["debug"] or self.module_params["debug"]:
|
|
self.results.update({"podman_version": self.container.version})
|
|
sysd = generate_systemd(
|
|
self.module, self.module_params, self.name, self.container.version
|
|
)
|
|
self.results["changed"] = changed or sysd["changed"]
|
|
self.results.update({"podman_systemd": sysd["systemd"]})
|
|
if sysd["diff"]:
|
|
if "diff" not in self.results:
|
|
self.results.update({"diff": sysd["diff"]})
|
|
else:
|
|
self.results["diff"]["before"] += sysd["diff"]["before"]
|
|
self.results["diff"]["after"] += sysd["diff"]["after"]
|
|
quadlet = ContainerQuadlet(self.module_params)
|
|
quadlet_content = quadlet.create_quadlet_content()
|
|
self.results.update({"podman_quadlet": quadlet_content})
|
|
|
|
def make_started(self):
|
|
"""Run actions if desired state is 'started'."""
|
|
if not self.image:
|
|
if not self.container.exists:
|
|
self.module.fail_json(
|
|
msg="Cannot start container when image" " is not specified!"
|
|
)
|
|
if self.restart:
|
|
self.container.restart()
|
|
self.results["actions"].append("restarted %s" % self.container.name)
|
|
else:
|
|
self.container.start()
|
|
self.results["actions"].append("started %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
if self.container.exists and self.restart:
|
|
if self.container.running:
|
|
self.container.restart()
|
|
self.results["actions"].append("restarted %s" % self.container.name)
|
|
else:
|
|
self.container.start()
|
|
self.results["actions"].append("started %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
if self.container.running and (self.container.different or self.recreate):
|
|
self.container.recreate_run()
|
|
self.results["actions"].append("recreated %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
elif self.container.running and not self.container.different:
|
|
if self.restart:
|
|
self.container.restart()
|
|
self.results["actions"].append("restarted %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
self.update_container_result(changed=False)
|
|
return
|
|
elif not self.container.exists:
|
|
self.container.run()
|
|
self.results["actions"].append("started %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
elif self.container.stopped and (self.container.different or self.recreate):
|
|
self.container.recreate_run()
|
|
self.results["actions"].append("recreated %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
elif self.container.stopped and not self.container.different:
|
|
self.container.start()
|
|
self.results["actions"].append("started %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
|
|
def make_created(self):
|
|
"""Run actions if desired state is 'created'."""
|
|
if not self.container.exists and not self.image:
|
|
self.module.fail_json(
|
|
msg="Cannot create container when image" " is not specified!"
|
|
)
|
|
if not self.container.exists:
|
|
self.container.create()
|
|
self.results["actions"].append("created %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
else:
|
|
if self.container.different or self.recreate:
|
|
self.container.recreate()
|
|
self.results["actions"].append("recreated %s" % self.container.name)
|
|
if self.container.running:
|
|
self.container.start()
|
|
self.results["actions"].append("started %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
elif self.restart:
|
|
if self.container.running:
|
|
self.container.restart()
|
|
self.results["actions"].append("restarted %s" % self.container.name)
|
|
else:
|
|
self.container.start()
|
|
self.results["actions"].append("started %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
self.update_container_result(changed=False)
|
|
return
|
|
|
|
def make_stopped(self):
|
|
"""Run actions if desired state is 'stopped'."""
|
|
if not self.container.exists and not self.image:
|
|
self.module.fail_json(
|
|
msg="Cannot create container when image" " is not specified!"
|
|
)
|
|
if not self.container.exists:
|
|
self.container.create()
|
|
self.results["actions"].append("created %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
if self.container.stopped:
|
|
self.update_container_result(changed=False)
|
|
return
|
|
elif self.container.running:
|
|
self.container.stop()
|
|
self.results["actions"].append("stopped %s" % self.container.name)
|
|
self.update_container_result()
|
|
return
|
|
|
|
def make_absent(self):
|
|
"""Run actions if desired state is 'absent'."""
|
|
if not self.container.exists:
|
|
self.results.update({"changed": False})
|
|
elif self.container.exists:
|
|
delete_systemd(
|
|
self.module, self.module_params, self.name, self.container.version
|
|
)
|
|
self.container.delete()
|
|
self.results["actions"].append("deleted %s" % self.container.name)
|
|
self.results.update({"changed": True})
|
|
self.results.update({"container": {}, "podman_actions": self.container.actions})
|
|
|
|
def make_quadlet(self):
|
|
results_update = create_quadlet_state(self.module, "container")
|
|
self.results.update(results_update)
|
|
|
|
def execute(self):
|
|
"""Execute the desired action according to map of actions & states."""
|
|
states_map = {
|
|
"present": self.make_created,
|
|
"started": self.make_started,
|
|
"absent": self.make_absent,
|
|
"stopped": self.make_stopped,
|
|
"created": self.make_created,
|
|
"quadlet": self.make_quadlet,
|
|
}
|
|
process_action = states_map[self.state]
|
|
process_action()
|
|
return self.results
|