ansible-collections/community.docker
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.docker.git synced 2026-03-15 19:58:28 +00:00
Code Packages Projects Releases Wiki Activity

Address use-dict-literal.

Browse Source
This commit is contained in:
Felix Fontein 2025-10-12 12:30:58 +02:00
parent 5184d6544f
commit 8ec904a7fd
48 changed files with 1448 additions and 1333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.pylintrc
View File

@ -393,7 +393,6 @@ disable=raw-checker-failed,
unexpected-keyword-arg,
unsupported-assignment-operation, # TODO: needs better typing info
unused-argument,
use-dict-literal,
# Cannot remove yet due to inadequacy of rules
inconsistent-return-statements, # doesn't notice that fail_json() does not return

2
plugins/connection/docker_api.py
View File

@ -183,7 +183,7 @@ class Connection(ConnectionBase):
super().__init__(play_context, new_stdin, *args, **kwargs)
self.client = None
self.ids = dict()
self.ids = {}
# Windows uses Powershell modules
if getattr(self._shell, "_IS_WINDOWS", False):

38
plugins/inventory/docker_containers.py
View File

@ -253,11 +253,11 @@ class InventoryModule(BaseInventoryPlugin, Constructable):
name = short_container_id
full_name = container_id
facts = dict(
docker_name=make_unsafe(name),
docker_short_id=make_unsafe(short_container_id),
)
full_facts = dict()
facts = {
"docker_name": make_unsafe(name),
"docker_short_id": make_unsafe(short_container_id),
}
full_facts = {}
try:
inspect = client.get_json("/containers/{0}/json", container_id)
@ -266,9 +266,9 @@ class InventoryModule(BaseInventoryPlugin, Constructable):
f"Error inspecting container {name} - {exc}"
) from exc
state = inspect.get("State") or dict()
config = inspect.get("Config") or dict()
labels = config.get("Labels") or dict()
state = inspect.get("State") or {}
config = inspect.get("Config") or {}
labels = config.get("Labels") or {}
running = state.get("Running")
@ -300,7 +300,7 @@ class InventoryModule(BaseInventoryPlugin, Constructable):
port_settings = network_settings.get("Ports") or {}
port = port_settings.get(f"{ssh_port}/tcp")[0]
except (IndexError, AttributeError, TypeError):
port = dict()
port = {}
try:
ip = default_ip if port["HostIp"] == "0.0.0.0" else port["HostIp"]
@ -308,23 +308,23 @@ class InventoryModule(BaseInventoryPlugin, Constructable):
ip = ""
facts.update(
dict(
ansible_ssh_host=ip,
ansible_ssh_port=port.get("HostPort", 0),
)
{
"ansible_ssh_host": ip,
"ansible_ssh_port": port.get("HostPort", 0),
}
)
elif connection_type == "docker-cli":
facts.update(
dict(
ansible_host=full_name,
)
{
"ansible_host": full_name,
}
)
ansible_connection = "community.docker.docker"
elif connection_type == "docker-api":
facts.update(
dict(
ansible_host=full_name,
)
{
"ansible_host": full_name,
}
)
facts.update(extra_facts)
ansible_connection = "community.docker.docker_api"

26
plugins/inventory/docker_swarm.py
View File

@ -184,19 +184,19 @@ class InventoryModule(BaseInventoryPlugin, Constructable):
raise AnsibleError(msg)
def _populate(self):
raw_params = dict(
docker_host=self.get_option("docker_host"),
tls=self.get_option("tls"),
tls_verify=self.get_option("validate_certs"),
key_path=self.get_option("client_key"),
cacert_path=self.get_option("ca_path"),
cert_path=self.get_option("client_cert"),
tls_hostname=self.get_option("tls_hostname"),
api_version=self.get_option("api_version"),
timeout=self.get_option("timeout"),
use_ssh_client=self.get_option("use_ssh_client"),
debug=None,
)
raw_params = {
"docker_host": self.get_option("docker_host"),
"tls": self.get_option("tls"),
"tls_verify": self.get_option("validate_certs"),
"key_path": self.get_option("client_key"),
"cacert_path": self.get_option("ca_path"),
"cert_path": self.get_option("client_cert"),
"tls_hostname": self.get_option("tls_hostname"),
"api_version": self.get_option("api_version"),
"timeout": self.get_option("timeout"),
"use_ssh_client": self.get_option("use_ssh_client"),
"debug": None,
}
update_tls_hostname(raw_params)
connect_params = get_connect_params(raw_params, fail_function=self._fail)
client = docker.DockerClient(**connect_params)

70
plugins/module_utils/_common.py
View File

@ -144,19 +144,19 @@ def get_connect_params(auth_data, fail_function):
"tcp://", "https://"
)
result = dict(
base_url=auth_data["docker_host"],
version=auth_data["api_version"],
timeout=auth_data["timeout"],
)
result = {
"base_url": auth_data["docker_host"],
"version": auth_data["api_version"],
"timeout": auth_data["timeout"],
}
if auth_data["tls_verify"]:
# TLS with verification
tls_config = dict(
verify=True,
assert_hostname=auth_data["tls_hostname"],
fail_function=fail_function,
)
tls_config = {
"verify": True,
"assert_hostname": auth_data["tls_hostname"],
"fail_function": fail_function,
}
if auth_data["cert_path"] and auth_data["key_path"]:
tls_config["client_cert"] = (auth_data["cert_path"], auth_data["key_path"])
if auth_data["cacert_path"]:
@ -164,10 +164,10 @@ def get_connect_params(auth_data, fail_function):
result["tls"] = _get_tls_config(**tls_config)
elif auth_data["tls"]:
# TLS without verification
tls_config = dict(
verify=False,
fail_function=fail_function,
)
tls_config = {
"verify": False,
"fail_function": fail_function,
}
if auth_data["cert_path"] and auth_data["key_path"]:
tls_config["client_cert"] = (auth_data["cert_path"], auth_data["key_path"])
result["tls"] = _get_tls_config(**tls_config)
@ -312,78 +312,78 @@ class AnsibleDockerClientBase(Client):
client_params = self._get_params()
params = dict()
params = {}
for key in DOCKER_COMMON_ARGS:
params[key] = client_params.get(key)
result = dict(
docker_host=self._get_value(
result = {
"docker_host": self._get_value(
"docker_host",
params["docker_host"],
"DOCKER_HOST",
DEFAULT_DOCKER_HOST,
value_type="str",
),
tls_hostname=self._get_value(
"tls_hostname": self._get_value(
"tls_hostname",
params["tls_hostname"],
"DOCKER_TLS_HOSTNAME",
None,
value_type="str",
),
api_version=self._get_value(
"api_version": self._get_value(
"api_version",
params["api_version"],
"DOCKER_API_VERSION",
"auto",
value_type="str",
),
cacert_path=self._get_value(
"cacert_path": self._get_value(
"cacert_path",
params["ca_path"],
"DOCKER_CERT_PATH",
None,
value_type="str",
),
cert_path=self._get_value(
"cert_path": self._get_value(
"cert_path",
params["client_cert"],
"DOCKER_CERT_PATH",
None,
value_type="str",
),
key_path=self._get_value(
"key_path": self._get_value(
"key_path",
params["client_key"],
"DOCKER_CERT_PATH",
None,
value_type="str",
),
tls=self._get_value(
"tls": self._get_value(
"tls", params["tls"], "DOCKER_TLS", DEFAULT_TLS, value_type="bool"
),
tls_verify=self._get_value(
"tls_verify": self._get_value(
"validate_certs",
params["validate_certs"],
"DOCKER_TLS_VERIFY",
DEFAULT_TLS_VERIFY,
value_type="bool",
),
timeout=self._get_value(
"timeout": self._get_value(
"timeout",
params["timeout"],
"DOCKER_TIMEOUT",
DEFAULT_TIMEOUT_SECONDS,
value_type="int",
),
use_ssh_client=self._get_value(
"use_ssh_client": self._get_value(
"use_ssh_client",
params["use_ssh_client"],
None,
False,
value_type="bool",
),
)
}
update_tls_hostname(result)
@ -586,11 +586,11 @@ class AnsibleDockerClientBase(Client):
"""
Pull an image
"""
kwargs = dict(
tag=tag,
stream=True,
decode=True,
)
kwargs = {
"tag": tag,
"stream": True,
"decode": True,
}
if image_platform is not None:
kwargs["platform"] = image_platform
self.log(f"Pulling image {name}:{tag}")
@ -654,7 +654,7 @@ class AnsibleDockerClient(AnsibleDockerClientBase):
# in case client.fail() is called.
self.fail_results = fail_results or {}
merged_arg_spec = dict()
merged_arg_spec = {}
merged_arg_spec.update(DOCKER_COMMON_ARGS)
if argument_spec:
merged_arg_spec.update(argument_spec)
@ -706,12 +706,12 @@ class AnsibleDockerClient(AnsibleDockerClientBase):
return self.module.params
def _get_minimal_versions(self, option_minimal_versions, ignore_params=None):
self.option_minimal_versions = dict()
self.option_minimal_versions = {}
for option in self.module.argument_spec:
if ignore_params is not None:
if option in ignore_params:
continue
self.option_minimal_versions[option] = dict()
self.option_minimal_versions[option] = {}
self.option_minimal_versions.update(option_minimal_versions)
for option, data in self.option_minimal_versions.items():

60
plugins/module_utils/_common_api.py
View File

@ -78,19 +78,19 @@ def get_connect_params(auth_data, fail_function):
"tcp://", "https://"
)
result = dict(
base_url=auth_data["docker_host"],
version=auth_data["api_version"],
timeout=auth_data["timeout"],
)
result = {
"base_url": auth_data["docker_host"],
"version": auth_data["api_version"],
"timeout": auth_data["timeout"],
}
if auth_data["tls_verify"]:
# TLS with verification
tls_config = dict(
verify=True,
assert_hostname=auth_data["tls_hostname"],
fail_function=fail_function,
)
tls_config = {
"verify": True,
"assert_hostname": auth_data["tls_hostname"],
"fail_function": fail_function,
}
if auth_data["cert_path"] and auth_data["key_path"]:
tls_config["client_cert"] = (auth_data["cert_path"], auth_data["key_path"])
if auth_data["cacert_path"]:
@ -98,10 +98,10 @@ def get_connect_params(auth_data, fail_function):
result["tls"] = _get_tls_config(**tls_config)
elif auth_data["tls"]:
# TLS without verification
tls_config = dict(
verify=False,
fail_function=fail_function,
)
tls_config = {
"verify": False,
"fail_function": fail_function,
}
if auth_data["cert_path"] and auth_data["key_path"]:
tls_config["client_cert"] = (auth_data["cert_path"], auth_data["key_path"])
result["tls"] = _get_tls_config(**tls_config)
@ -203,78 +203,78 @@ class AnsibleDockerClientBase(Client):
client_params = self._get_params()
params = dict()
params = {}
for key in DOCKER_COMMON_ARGS:
params[key] = client_params.get(key)
result = dict(
docker_host=self._get_value(
result = {
"docker_host": self._get_value(
"docker_host",
params["docker_host"],
"DOCKER_HOST",
DEFAULT_DOCKER_HOST,
value_type="str",
),
tls_hostname=self._get_value(
"tls_hostname": self._get_value(
"tls_hostname",
params["tls_hostname"],
"DOCKER_TLS_HOSTNAME",
None,
value_type="str",
),
api_version=self._get_value(
"api_version": self._get_value(
"api_version",
params["api_version"],
"DOCKER_API_VERSION",
"auto",
value_type="str",
),
cacert_path=self._get_value(
"cacert_path": self._get_value(
"cacert_path",
params["ca_path"],
"DOCKER_CERT_PATH",
None,
value_type="str",
),
cert_path=self._get_value(
"cert_path": self._get_value(
"cert_path",
params["client_cert"],
"DOCKER_CERT_PATH",
None,
value_type="str",
),
key_path=self._get_value(
"key_path": self._get_value(
"key_path",
params["client_key"],
"DOCKER_CERT_PATH",
None,
value_type="str",
),
tls=self._get_value(
"tls": self._get_value(
"tls", params["tls"], "DOCKER_TLS", DEFAULT_TLS, value_type="bool"
),
tls_verify=self._get_value(
"tls_verify": self._get_value(
"validate_certs",
params["validate_certs"],
"DOCKER_TLS_VERIFY",
DEFAULT_TLS_VERIFY,
value_type="bool",
),
timeout=self._get_value(
"timeout": self._get_value(
"timeout",
params["timeout"],
"DOCKER_TIMEOUT",
DEFAULT_TIMEOUT_SECONDS,
value_type="int",
),
use_ssh_client=self._get_value(
"use_ssh_client": self._get_value(
"use_ssh_client",
params["use_ssh_client"],
None,
False,
value_type="bool",
),
)
}
def depr(*args, **kwargs):
self.deprecate(*args, **kwargs)
@ -564,7 +564,7 @@ class AnsibleDockerClient(AnsibleDockerClientBase):
# in case client.fail() is called.
self.fail_results = fail_results or {}
merged_arg_spec = dict()
merged_arg_spec = {}
merged_arg_spec.update(DOCKER_COMMON_ARGS)
if argument_spec:
merged_arg_spec.update(argument_spec)
@ -613,12 +613,12 @@ class AnsibleDockerClient(AnsibleDockerClientBase):
return self.module.params
def _get_minimal_versions(self, option_minimal_versions, ignore_params=None):
self.option_minimal_versions = dict()
self.option_minimal_versions = {}
for option in self.module.argument_spec:
if ignore_params is not None:
if option in ignore_params:
continue
self.option_minimal_versions[option] = dict()
self.option_minimal_versions[option] = {}
self.option_minimal_versions.update(option_minimal_versions)
for option, data in self.option_minimal_versions.items():

61
plugins/module_utils/_common_cli.py
View File

@ -31,31 +31,40 @@ from ansible_collections.community.docker.plugins.module_utils._version import (
)
DOCKER_COMMON_ARGS = dict(
docker_cli=dict(type="path"),
docker_host=dict(
type="str", fallback=(env_fallback, ["DOCKER_HOST"]), aliases=["docker_url"]
),
tls_hostname=dict(type="str", fallback=(env_fallback, ["DOCKER_TLS_HOSTNAME"])),
api_version=dict(
type="str",
default="auto",
fallback=(env_fallback, ["DOCKER_API_VERSION"]),
aliases=["docker_api_version"],
),
ca_path=dict(type="path", aliases=["ca_cert", "tls_ca_cert", "cacert_path"]),
client_cert=dict(type="path", aliases=["tls_client_cert", "cert_path"]),
client_key=dict(type="path", aliases=["tls_client_key", "key_path"]),
tls=dict(type="bool", default=DEFAULT_TLS, fallback=(env_fallback, ["DOCKER_TLS"])),
validate_certs=dict(
type="bool",
default=DEFAULT_TLS_VERIFY,
fallback=(env_fallback, ["DOCKER_TLS_VERIFY"]),
aliases=["tls_verify"],
),
# debug=dict(type='bool', default=False),
cli_context=dict(type="str"),
)
DOCKER_COMMON_ARGS = {
"docker_cli": {"type": "path"},
"docker_host": {
"type": "str",
"fallback": (env_fallback, ["DOCKER_HOST"]),
"aliases": ["docker_url"],
},
"tls_hostname": {
"type": "str",
"fallback": (env_fallback, ["DOCKER_TLS_HOSTNAME"]),
},
"api_version": {
"type": "str",
"default": "auto",
"fallback": (env_fallback, ["DOCKER_API_VERSION"]),
"aliases": ["docker_api_version"],
},
"ca_path": {"type": "path", "aliases": ["ca_cert", "tls_ca_cert", "cacert_path"]},
"client_cert": {"type": "path", "aliases": ["tls_client_cert", "cert_path"]},
"client_key": {"type": "path", "aliases": ["tls_client_key", "key_path"]},
"tls": {
"type": "bool",
"default": DEFAULT_TLS,
"fallback": (env_fallback, ["DOCKER_TLS"]),
},
"validate_certs": {
"type": "bool",
"default": DEFAULT_TLS_VERIFY,
"fallback": (env_fallback, ["DOCKER_TLS_VERIFY"]),
"aliases": ["tls_verify"],
},
# "debug": {"type": "bool", "default: False},
"cli_context": {"type": "str"},
}
class DockerException(Exception):
@ -327,7 +336,7 @@ class AnsibleModuleDockerClient(AnsibleDockerClientBase):
# in case client.fail() is called.
self.fail_results = fail_results or {}
merged_arg_spec = dict()
merged_arg_spec = {}
merged_arg_spec.update(DOCKER_COMMON_ARGS)
if argument_spec:
merged_arg_spec.update(argument_spec)

34
plugins/module_utils/_compose_v2.py
View File

@ -691,28 +691,28 @@ def update_failed(result, events, args, stdout, stderr, rc, cli):
def common_compose_argspec():
return dict(
project_src=dict(type="path"),
project_name=dict(type="str"),
files=dict(type="list", elements="path"),
definition=dict(type="dict"),
env_files=dict(type="list", elements="path"),
profiles=dict(type="list", elements="str"),
check_files_existing=dict(type="bool", default=True),
)
return {
"project_src": {"type": "path"},
"project_name": {"type": "str"},
"files": {"type": "list", "elements": "path"},
"definition": {"type": "dict"},
"env_files": {"type": "list", "elements": "path"},
"profiles": {"type": "list", "elements": "str"},
"check_files_existing": {"type": "bool", "default": True},
}
def common_compose_argspec_ex():
return dict(
argspec=common_compose_argspec(),
mutually_exclusive=[("definition", "project_src"), ("definition", "files")],
required_one_of=[
return {
"argspec": common_compose_argspec(),
"mutually_exclusive": [("definition", "project_src"), ("definition", "files")],
"required_one_of": [
("definition", "project_src"),
],
required_by={
"required_by": {
"definition": ("project_name",),
},
)
}
def combine_binary_output(*outputs):
@ -853,7 +853,7 @@ class BaseComposeManager(DockerBaseClass):
if self.compose_version >= LooseVersion("2.23.0"):
# https://github.com/docker/compose/pull/11038
args.append("--no-trunc")
kwargs = dict(cwd=self.project_src, check_rc=not self.use_json_events)
kwargs = {"cwd": self.project_src, "check_rc": not self.use_json_events}
if self.compose_version >= LooseVersion("2.21.0"):
# Breaking change in 2.21.0: https://github.com/docker/compose/pull/10918
rc, containers, stderr = self.client.call_cli_json_stream(*args, **kwargs)
@ -882,7 +882,7 @@ class BaseComposeManager(DockerBaseClass):
def list_images(self):
args = self.get_base_args() + ["images", "--format", "json"]
kwargs = dict(cwd=self.project_src, check_rc=not self.use_json_events)
kwargs = {"cwd": self.project_src, "check_rc": not self.use_json_events}
rc, images, stderr = self.client.call_cli_json(*args, **kwargs)
if self.use_json_events and rc != 0:
self._handle_failed_cli_call(args, rc, images, stderr)

184
plugins/module_utils/_module_container/base.py
View File

@ -37,21 +37,21 @@ _DEFAULT_IP_REPLACEMENT_STRING = (
)
_MOUNT_OPTION_TYPES = dict(
create_mountpoint=("bind",),
labels=("volume",),
no_copy=("volume",),
non_recursive=("bind",),
propagation=("bind",),
read_only_force_recursive=("bind",),
read_only_non_recursive=("bind",),
subpath=("volume", "image"),
tmpfs_size=("tmpfs",),
tmpfs_mode=("tmpfs",),
tmpfs_options=("tmpfs",),
volume_driver=("volume",),
volume_options=("volume",),
)
_MOUNT_OPTION_TYPES = {
"create_mountpoint": ("bind",),
"labels": ("volume",),
"no_copy": ("volume",),
"non_recursive": ("bind",),
"propagation": ("bind",),
"read_only_force_recursive": ("bind",),
"read_only_non_recursive": ("bind",),
"subpath": ("volume", "image"),
"tmpfs_size": ("tmpfs",),
"tmpfs_mode": ("tmpfs",),
"tmpfs_options": ("tmpfs",),
"volume_driver": ("volume",),
"volume_options": ("volume",),
}
def _get_ansible_type(value_type):
@ -629,7 +629,7 @@ def _preprocess_ulimits(module, values):
return values
result = []
for limit in values["ulimits"]:
limits = dict()
limits = {}
pieces = limit.split(":")
if len(pieces) >= 2:
limits["Name"] = pieces[0]
@ -644,7 +644,7 @@ def _preprocess_ulimits(module, values):
def _preprocess_mounts(module, values):
last = dict()
last = {}
def check_collision(t, name):
if t in last:
@ -970,53 +970,53 @@ OPTION_DEVICE_READ_BPS = OptionGroup().add_option(
"device_read_bps",
value_type="set",
elements="dict",
ansible_suboptions=dict(
path=dict(required=True, type="str"),
rate=dict(required=True, type="str"),
),
ansible_suboptions={
"path": {"type": "str", "required": True},
"rate": {"type": "str", "required": True},
},
)
OPTION_DEVICE_WRITE_BPS = OptionGroup().add_option(
"device_write_bps",
value_type="set",
elements="dict",
ansible_suboptions=dict(
path=dict(required=True, type="str"),
rate=dict(required=True, type="str"),
),
ansible_suboptions={
"path": {"type": "str", "required": True},
"rate": {"type": "str", "required": True},
},
)
OPTION_DEVICE_READ_IOPS = OptionGroup().add_option(
"device_read_iops",
value_type="set",
elements="dict",
ansible_suboptions=dict(
path=dict(required=True, type="str"),
rate=dict(required=True, type="int"),
),
ansible_suboptions={
"path": {"type": "str", "required": True},
"rate": {"type": "int", "required": True},
},
)
OPTION_DEVICE_WRITE_IOPS = OptionGroup().add_option(
"device_write_iops",
value_type="set",
elements="dict",
ansible_suboptions=dict(
path=dict(required=True, type="str"),
rate=dict(required=True, type="int"),
),
ansible_suboptions={
"path": {"type": "str", "required": True},
"rate": {"type": "int", "required": True},
},
)
OPTION_DEVICE_REQUESTS = OptionGroup().add_option(
"device_requests",
value_type="set",
elements="dict",
ansible_suboptions=dict(
capabilities=dict(type="list", elements="list"),
count=dict(type="int"),
device_ids=dict(type="list", elements="str"),
driver=dict(type="str"),
options=dict(type="dict"),
),
ansible_suboptions={
"capabilities": {"type": "list", "elements": "list"},
"count": {"type": "int"},
"device_ids": {"type": "list", "elements": "str"},
"driver": {"type": "str"},
"options": {"type": "dict"},
},
)
OPTION_DEVICE_CGROUP_RULES = OptionGroup().add_option(
@ -1066,15 +1066,15 @@ OPTION_GROUPS = OptionGroup().add_option("groups", value_type="set", elements="s
OPTION_HEALTHCHECK = OptionGroup(preprocess=_preprocess_healthcheck).add_option(
"healthcheck",
value_type="dict",
ansible_suboptions=dict(
test=dict(type="raw"),
test_cli_compatible=dict(type="bool", default=False),
interval=dict(type="str"),
timeout=dict(type="str"),
start_period=dict(type="str"),
start_interval=dict(type="str"),
retries=dict(type="int"),
),
ansible_suboptions={
"test": {"type": "raw"},
"test_cli_compatible": {"type": "bool", "default": False},
"interval": {"type": "str"},
"timeout": {"type": "str"},
"start_period": {"type": "str"},
"start_interval": {"type": "str"},
"retries": {"type": "int"},
},
)
OPTION_HOSTNAME = OptionGroup().add_option("hostname", value_type="str")
@ -1143,16 +1143,16 @@ OPTION_NETWORK = (
"networks",
value_type="set",
elements="dict",
ansible_suboptions=dict(
name=dict(type="str", required=True),
ipv4_address=dict(type="str"),
ipv6_address=dict(type="str"),
aliases=dict(type="list", elements="str"),
links=dict(type="list", elements="str"),
mac_address=dict(type="str"),
driver_opts=dict(type="dict"),
gw_priority=dict(type="int"),
),
ansible_suboptions={
"name": {"type": "str", "required": True},
"ipv4_address": {"type": "str"},
"ipv6_address": {"type": "str"},
"aliases": {"type": "list", "elements": "str"},
"links": {"type": "list", "elements": "str"},
"mac_address": {"type": "str"},
"driver_opts": {"type": "dict"},
"gw_priority": {"type": "int"},
},
)
)
@ -1232,35 +1232,43 @@ OPTION_MOUNTS_VOLUMES = (
"mounts",
value_type="set",
elements="dict",
ansible_suboptions=dict(
target=dict(type="str", required=True),
source=dict(type="str"),
type=dict(
type="str",
choices=["bind", "volume", "tmpfs", "npipe", "cluster", "image"],
default="volume",
),
read_only=dict(type="bool"),
consistency=dict(
type="str", choices=["default", "consistent", "cached", "delegated"]
),
propagation=dict(
type="str",
choices=["private", "rprivate", "shared", "rshared", "slave", "rslave"],
),
no_copy=dict(type="bool"),
labels=dict(type="dict"),
volume_driver=dict(type="str"),
volume_options=dict(type="dict"),
tmpfs_size=dict(type="str"),
tmpfs_mode=dict(type="str"),
non_recursive=dict(type="bool"),
create_mountpoint=dict(type="bool"),
read_only_non_recursive=dict(type="bool"),
read_only_force_recursive=dict(type="bool"),
subpath=dict(type="str"),
tmpfs_options=dict(type="list", elements="dict"),
),
ansible_suboptions={
"target": {"type": "str", "required": True},
"source": {"type": "str"},
"type": {
"type": "str",
"choices": ["bind", "volume", "tmpfs", "npipe", "cluster", "image"],
"default": "volume",
},
"read_only": {"type": "bool"},
"consistency": {
"type": "str",
"choices": ["default", "consistent", "cached", "delegated"],
},
"propagation": {
"type": "str",
"choices": [
"private",
"rprivate",
"shared",
"rshared",
"slave",
"rslave",
],
},
"no_copy": {"type": "bool"},
"labels": {"type": "dict"},
"volume_driver": {"type": "str"},
"volume_options": {"type": "dict"},
"tmpfs_size": {"type": "str"},
"tmpfs_mode": {"type": "str"},
"non_recursive": {"type": "bool"},
"create_mountpoint": {"type": "bool"},
"read_only_non_recursive": {"type": "bool"},
"read_only_force_recursive": {"type": "bool"},
"subpath": {"type": "str"},
"tmpfs_options": {"type": "list", "elements": "dict"},
},
)
.add_option("volumes", value_type="set", elements="str")
.add_option(

36
plugins/module_utils/_module_container/docker_api.py
View File

@ -821,28 +821,28 @@ def _preprocess_devices(module, client, api_version, value):
parts = device.split(":")
if len(parts) == 1:
expected_devices.append(
dict(
CgroupPermissions="rwm",
PathInContainer=parts[0],
PathOnHost=parts[0],
)
{
"CgroupPermissions": "rwm",
"PathInContainer": parts[0],
"PathOnHost": parts[0],
}
)
elif len(parts) == 2:
parts = device.split(":")
expected_devices.append(
dict(
CgroupPermissions="rwm",
PathInContainer=parts[1],
PathOnHost=parts[0],
)
{
"CgroupPermissions": "rwm",
"PathInContainer": parts[1],
"PathOnHost": parts[0],
}
)
else:
expected_devices.append(
dict(
CgroupPermissions=parts[2],
PathInContainer=parts[1],
PathOnHost=parts[0],
)
{
"CgroupPermissions": parts[2],
"PathInContainer": parts[1],
"PathOnHost": parts[0],
}
)
return expected_devices
@ -1190,7 +1190,7 @@ def _get_expected_values_mounts(
expected_values["mounts"] = values["mounts"]
# volumes
expected_vols = dict()
expected_vols = {}
if image and image["Config"].get("Volumes"):
expected_vols.update(image["Config"].get("Volumes"))
if "volumes" in values:
@ -1404,9 +1404,7 @@ def _get_values_ports(module, container, api_version, options, image, host_info)
# "ExposedPorts": null returns None type & causes AttributeError - PR #5517
if config.get("ExposedPorts") is not None:
expected_exposed = [
_normalize_port(p) for p in config.get("ExposedPorts", dict()).keys()
]
expected_exposed = [_normalize_port(p) for p in config.get("ExposedPorts", {})]
else:
expected_exposed = []

215
plugins/module_utils/_module_container/module.py
View File

@ -232,17 +232,17 @@ class ContainerManager(DockerBaseClass):
"name"
]
if self.param_container_default_behavior == "compatibility":
old_default_values = dict(
auto_remove=False,
detach=True,
init=False,
interactive=False,
memory="0",
paused=False,
privileged=False,
read_only=False,
tty=False,
)
old_default_values = {
"auto_remove": False,
"detach": True,
"init": False,
"interactive": False,
"memory": "0",
"paused": False,
"privileged": False,
"read_only": False,
"tty": False,
}
for param, value in old_default_values.items():
if self.module.params[param] is None:
self.module.params[param] = value
@ -487,7 +487,7 @@ class ContainerManager(DockerBaseClass):
)
container = self._get_container(container.id)
self.results["changed"] = True
self.results["actions"].append(dict(set_paused=self.param_paused))
self.results["actions"].append({"set_paused": self.param_paused})
self.facts = container.raw
@ -577,19 +577,19 @@ class ContainerManager(DockerBaseClass):
if already_to_latest:
self.results["changed"] = False
self.results["actions"].append(
dict(pulled_image=f"{repository}:{tag}", changed=False)
{"pulled_image": f"{repository}:{tag}", "changed": False}
)
else:
self.results["changed"] = True
self.results["actions"].append(
dict(pulled_image=f"{repository}:{tag}", changed=True)
{"pulled_image": f"{repository}:{tag}", "changed": True}
)
elif not image or self.param_pull_check_mode_behavior == "always":
# If the image is not there, or pull_check_mode_behavior == 'always', claim we'll
# pull. (Implicitly: if the image is there, claim it already was latest unless
# pull_check_mode_behavior == 'always'.)
self.results["changed"] = True
action = dict(pulled_image=f"{repository}:{tag}")
action = {"pulled_image": f"{repository}:{tag}"}
if not image:
action["changed"] = True
self.results["actions"].append(action)
@ -817,7 +817,7 @@ class ContainerManager(DockerBaseClass):
network_info = connected_networks.get(network["name"])
if network_info is None:
different = True
differences.append(dict(parameter=network, container=None))
differences.append({"parameter": network, "container": None})
else:
diff = False
network_info_ipam = network_info.get("IPAMConfig") or {}
@ -855,17 +855,17 @@ class ContainerManager(DockerBaseClass):
if diff:
different = True
differences.append(
dict(
parameter=network,
container=dict(
name=network["name"],
ipv4_address=network_info_ipam.get("IPv4Address"),
ipv6_address=network_info_ipam.get("IPv6Address"),
aliases=network_info.get("Aliases"),
links=network_info.get("Links"),
mac_address=network_info.get("MacAddress"),
),
)
{
"parameter": network,
"container": {
"name": network["name"],
"ipv4_address": network_info_ipam.get("IPv4Address"),
"ipv6_address": network_info_ipam.get("IPv6Address"),
"aliases": network_info.get("Aliases"),
"links": network_info.get("Links"),
"mac_address": network_info.get("MacAddress"),
},
}
)
return different, differences
@ -892,7 +892,7 @@ class ContainerManager(DockerBaseClass):
if not keep:
extra = True
extra_networks.append(
dict(name=network, id=network_config["NetworkID"])
{"name": network, "id": network_config["NetworkID"]}
)
return extra, extra_networks
@ -905,11 +905,11 @@ class ContainerManager(DockerBaseClass):
if has_network_differences:
if self.diff.get("differences"):
self.diff["differences"].append(
dict(network_differences=network_differences)
{"network_differences": network_differences}
)
else:
self.diff["differences"] = [
dict(network_differences=network_differences)
{"network_differences": network_differences}
]
for netdiff in network_differences:
self.diff_tracker.add(
@ -928,9 +928,9 @@ class ContainerManager(DockerBaseClass):
has_extra_networks, extra_networks = self.has_extra_networks(container)
if has_extra_networks:
if self.diff.get("differences"):
self.diff["differences"].append(dict(purge_networks=extra_networks))
self.diff["differences"].append({"purge_networks": extra_networks})
else:
self.diff["differences"] = [dict(purge_networks=extra_networks)]
self.diff["differences"] = [{"purge_networks": extra_networks}]
for extra_network in extra_networks:
self.diff_tracker.add(
f"network.{extra_network['name']}", active=extra_network
@ -944,7 +944,7 @@ class ContainerManager(DockerBaseClass):
# remove the container from the network, if connected
if diff.get("container"):
self.results["actions"].append(
dict(removed_from_network=diff["parameter"]["name"])
{"removed_from_network": diff["parameter"]["name"]}
)
if not self.check_mode:
try:
@ -957,10 +957,10 @@ class ContainerManager(DockerBaseClass):
)
# connect to the network
self.results["actions"].append(
dict(
added_to_network=diff["parameter"]["name"],
network_parameters=diff["parameter"],
)
{
"added_to_network": diff["parameter"]["name"],
"network_parameters": diff["parameter"],
}
)
if not self.check_mode:
params = {
@ -984,7 +984,7 @@ class ContainerManager(DockerBaseClass):
def _purge_networks(self, container, networks):
for network in networks:
self.results["actions"].append(dict(removed_from_network=network["name"]))
self.results["actions"].append({"removed_from_network": network["name"]})
if not self.check_mode:
try:
self.engine_driver.disconnect_container_from_network(
@ -1015,11 +1015,11 @@ class ContainerManager(DockerBaseClass):
if key not in ("name", "id")
}
self.results["actions"].append(
dict(
created="Created container",
create_parameters=create_parameters,
networks=networks,
)
{
"created": "Created container",
"create_parameters": create_parameters,
"networks": networks,
}
)
self.results["changed"] = True
new_container = None
@ -1035,7 +1035,7 @@ class ContainerManager(DockerBaseClass):
def container_start(self, container_id):
self.log(f"start container {container_id}")
self.results["actions"].append(dict(started=container_id))
self.results["actions"].append({"started": container_id})
self.results["changed"] = True
if not self.check_mode:
try:
@ -1069,7 +1069,7 @@ class ContainerManager(DockerBaseClass):
if insp.raw:
insp.raw["Output"] = output
else:
insp.raw = dict(Output=output)
insp.raw = {"Output": output}
if status != 0:
# Set `failed` to True and return output as msg
self.results["failed"] = True
@ -1083,9 +1083,12 @@ class ContainerManager(DockerBaseClass):
f"remove container container:{container_id} v:{volume_state} link:{link} force{force}"
)
self.results["actions"].append(
dict(
removed=container_id, volume_state=volume_state, link=link, force=force
)
{
"removed": container_id,
"volume_state": volume_state,
"link": link,
"force": force,
}
)
self.results["changed"] = True
if not self.check_mode:
@ -1105,7 +1108,7 @@ class ContainerManager(DockerBaseClass):
self.log(f"update container {container_id}")
self.log(update_parameters, pretty_print=True)
self.results["actions"].append(
dict(updated=container_id, update_parameters=update_parameters)
{"updated": container_id, "update_parameters": update_parameters}
)
self.results["changed"] = True
if not self.check_mode:
@ -1119,7 +1122,7 @@ class ContainerManager(DockerBaseClass):
def container_kill(self, container_id):
self.results["actions"].append(
dict(killed=container_id, signal=self.param_kill_signal)
{"killed": container_id, "signal": self.param_kill_signal}
)
self.results["changed"] = True
if not self.check_mode:
@ -1132,7 +1135,7 @@ class ContainerManager(DockerBaseClass):
def container_restart(self, container_id):
self.results["actions"].append(
dict(restarted=container_id, timeout=self.module.params["stop_timeout"])
{"restarted": container_id, "timeout": self.module.params["stop_timeout"]}
)
self.results["changed"] = True
if not self.check_mode:
@ -1149,7 +1152,7 @@ class ContainerManager(DockerBaseClass):
self.container_kill(container_id)
return
self.results["actions"].append(
dict(stopped=container_id, timeout=self.module.params["stop_timeout"])
{"stopped": container_id, "timeout": self.module.params["stop_timeout"]}
)
self.results["changed"] = True
if not self.check_mode:
@ -1163,57 +1166,63 @@ class ContainerManager(DockerBaseClass):
def run_module(engine_driver):
module, active_options, client = engine_driver.setup(
argument_spec=dict(
cleanup=dict(type="bool", default=False),
comparisons=dict(type="dict"),
container_default_behavior=dict(
type="str",
default="no_defaults",
choices=["compatibility", "no_defaults"],
),
command_handling=dict(
type="str", choices=["compatibility", "correct"], default="correct"
),
default_host_ip=dict(type="str"),
force_kill=dict(type="bool", default=False, aliases=["forcekill"]),
image=dict(type="str"),
image_comparison=dict(
type="str",
choices=["desired-image", "current-image"],
default="desired-image",
),
image_label_mismatch=dict(
type="str", choices=["ignore", "fail"], default="ignore"
),
image_name_mismatch=dict(
type="str", choices=["ignore", "recreate"], default="recreate"
),
keep_volumes=dict(type="bool", default=True),
kill_signal=dict(type="str"),
name=dict(type="str", required=True),
networks_cli_compatible=dict(type="bool", default=True),
output_logs=dict(type="bool", default=False),
paused=dict(type="bool"),
pull=dict(
type="raw",
choices=["never", "missing", "always", True, False],
default="missing",
),
pull_check_mode_behavior=dict(
type="str",
choices=["image_not_present", "always"],
default="image_not_present",
),
recreate=dict(type="bool", default=False),
removal_wait_timeout=dict(type="float"),
restart=dict(type="bool", default=False),
state=dict(
type="str",
default="started",
choices=["absent", "present", "healthy", "started", "stopped"],
),
healthy_wait_timeout=dict(type="float", default=300),
),
argument_spec={
"cleanup": {"type": "bool", "default": False},
"comparisons": {"type": "dict"},
"container_default_behavior": {
"type": "str",
"default": "no_defaults",
"choices": ["compatibility", "no_defaults"],
},
"command_handling": {
"type": "str",
"choices": ["compatibility", "correct"],
"default": "correct",
},
"default_host_ip": {"type": "str"},
"force_kill": {"type": "bool", "default": False, "aliases": ["forcekill"]},
"image": {"type": "str"},
"image_comparison": {
"type": "str",
"choices": ["desired-image", "current-image"],
"default": "desired-image",
},
"image_label_mismatch": {
"type": "str",
"choices": ["ignore", "fail"],
"default": "ignore",
},
"image_name_mismatch": {
"type": "str",
"choices": ["ignore", "recreate"],
"default": "recreate",
},
"keep_volumes": {"type": "bool", "default": True},
"kill_signal": {"type": "str"},
"name": {"type": "str", "required": True},
"networks_cli_compatible": {"type": "bool", "default": True},
"output_logs": {"type": "bool", "default": False},
"paused": {"type": "bool"},
"pull": {
"type": "raw",
"choices": ["never", "missing", "always", True, False],
"default": "missing",
},
"pull_check_mode_behavior": {
"type": "str",
"choices": ["image_not_present", "always"],
"default": "image_not_present",
},
"recreate": {"type": "bool", "default": False},
"removal_wait_timeout": {"type": "float"},
"restart": {"type": "bool", "default": False},
"state": {
"type": "str",
"default": "started",
"choices": ["absent", "present", "healthy", "started", "stopped"],
},
"healthy_wait_timeout": {"type": "float", "default": 300},
},
required_if=[
("state", "present", ["image"]),
],

99
plugins/module_utils/_util.py
View File

@ -23,38 +23,45 @@ DEFAULT_TLS_VERIFY = False
DEFAULT_TLS_HOSTNAME = "localhost" # deprecated
DEFAULT_TIMEOUT_SECONDS = 60
DOCKER_COMMON_ARGS = dict(
docker_host=dict(
type="str",
default=DEFAULT_DOCKER_HOST,
fallback=(env_fallback, ["DOCKER_HOST"]),
aliases=["docker_url"],
),
tls_hostname=dict(type="str", fallback=(env_fallback, ["DOCKER_TLS_HOSTNAME"])),
api_version=dict(
type="str",
default="auto",
fallback=(env_fallback, ["DOCKER_API_VERSION"]),
aliases=["docker_api_version"],
),
timeout=dict(
type="int",
default=DEFAULT_TIMEOUT_SECONDS,
fallback=(env_fallback, ["DOCKER_TIMEOUT"]),
),
ca_path=dict(type="path", aliases=["ca_cert", "tls_ca_cert", "cacert_path"]),
client_cert=dict(type="path", aliases=["tls_client_cert", "cert_path"]),
client_key=dict(type="path", aliases=["tls_client_key", "key_path"]),
tls=dict(type="bool", default=DEFAULT_TLS, fallback=(env_fallback, ["DOCKER_TLS"])),
use_ssh_client=dict(type="bool", default=False),
validate_certs=dict(
type="bool",
default=DEFAULT_TLS_VERIFY,
fallback=(env_fallback, ["DOCKER_TLS_VERIFY"]),
aliases=["tls_verify"],
),
debug=dict(type="bool", default=False),
)
DOCKER_COMMON_ARGS = {
"docker_host": {
"type": "str",
"default": DEFAULT_DOCKER_HOST,
"fallback": (env_fallback, ["DOCKER_HOST"]),
"aliases": ["docker_url"],
},
"tls_hostname": {
"type": "str",
"fallback": (env_fallback, ["DOCKER_TLS_HOSTNAME"]),
},
"api_version": {
"type": "str",
"default": "auto",
"fallback": (env_fallback, ["DOCKER_API_VERSION"]),
"aliases": ["docker_api_version"],
},
"timeout": {
"type": "int",
"default": DEFAULT_TIMEOUT_SECONDS,
"fallback": (env_fallback, ["DOCKER_TIMEOUT"]),
},
"ca_path": {"type": "path", "aliases": ["ca_cert", "tls_ca_cert", "cacert_path"]},
"client_cert": {"type": "path", "aliases": ["tls_client_cert", "cert_path"]},
"client_key": {"type": "path", "aliases": ["tls_client_key", "key_path"]},
"tls": {
"type": "bool",
"default": DEFAULT_TLS,
"fallback": (env_fallback, ["DOCKER_TLS"]),
},
"use_ssh_client": {"type": "bool", "default": False},
"validate_certs": {
"type": "bool",
"default": DEFAULT_TLS_VERIFY,
"fallback": (env_fallback, ["DOCKER_TLS_VERIFY"]),
"aliases": ["tls_verify"],
},
"debug": {"type": "bool", "default": False},
}
DOCKER_COMMON_ARGS_VARS = {
option_name: f"ansible_docker_{option_name}"
@ -245,11 +252,11 @@ class DifferenceTracker:
def add(self, name, parameter=None, active=None):
self._diff.append(
dict(
name=name,
parameter=parameter,
active=active,
)
{
"name": name,
"parameter": parameter,
"active": active,
}
)
def merge(self, other_tracker):
@ -263,8 +270,8 @@ class DifferenceTracker:
"""
Return texts ``before`` and ``after``.
"""
before = dict()
after = dict()
before = {}
after = {}
for item in self._diff:
before[item["name"]] = item["active"]
after[item["name"]] = item["parameter"]
@ -282,11 +289,11 @@ class DifferenceTracker:
"""
result = []
for entry in self._diff:
item = dict()
item[entry["name"]] = dict(
parameter=entry["parameter"],
container=entry["active"],
)
item = {}
item[entry["name"]] = {
"parameter": entry["parameter"],
"container": entry["active"],
}
result.append(item)
return result
@ -335,7 +342,7 @@ def clean_dict_booleans_for_docker_api(data, allow_sequences=False):
return "false"
return str(value)
result = dict()
result = {}
if data is not None:
for k, v in data.items():
result[str(k)] = (
@ -389,7 +396,7 @@ def normalize_healthcheck(healthcheck, normalize_test=False):
"""
Return dictionary of healthcheck parameters.
"""
result = dict()
result = {}
# All supported healthcheck parameters
options = (

12
plugins/modules/current_container_facts.py
View File

@ -80,7 +80,7 @@ from ansible.module_utils.basic import AnsibleModule
def main():
module = AnsibleModule(dict(), supports_check_mode=True)
module = AnsibleModule({}, supports_check_mode=True)
cpuset_path = "/proc/self/cpuset"
mountinfo_path = "/proc/self/mountinfo"
@ -136,11 +136,11 @@ def main():
container_type = "podman"
module.exit_json(
ansible_facts=dict(
ansible_module_running_in_container=container_id != "",
ansible_module_container_id=container_id,
ansible_module_container_type=container_type,
)
ansible_facts={
"ansible_module_running_in_container": container_id != "",
"ansible_module_container_id": container_id,
"ansible_module_container_type": container_type,
}
)

68
plugins/modules/docker_compose_v2.py
View File

@ -550,7 +550,7 @@ class ServicesManager(BaseComposeManager):
return args
def cmd_up(self):
result = dict()
result = {}
args = self.get_up_cmd(self.check_mode)
rc, stdout, stderr = self.client.call_cli(*args, cwd=self.project_src)
events = self.parse_events(stderr, dry_run=self.check_mode, nonzero_rc=rc != 0)
@ -587,7 +587,7 @@ class ServicesManager(BaseComposeManager):
# Since 'docker compose stop' **always** claims it is stopping containers, even if they are already
# stopped, we have to do this a bit more complicated.
result = dict()
result = {}
# Make sure all containers are created
args_1 = self.get_up_cmd(self.check_mode, no_start=True)
rc_1, stdout_1, stderr_1 = self.client.call_cli(*args_1, cwd=self.project_src)
@ -644,7 +644,7 @@ class ServicesManager(BaseComposeManager):
return args
def cmd_restart(self):
result = dict()
result = {}
args = self.get_restart_cmd(self.check_mode)
rc, stdout, stderr = self.client.call_cli(*args, cwd=self.project_src)
events = self.parse_events(stderr, dry_run=self.check_mode, nonzero_rc=rc != 0)
@ -671,7 +671,7 @@ class ServicesManager(BaseComposeManager):
return args
def cmd_down(self):
result = dict()
result = {}
args = self.get_down_cmd(self.check_mode)
rc, stdout, stderr = self.client.call_cli(*args, cwd=self.project_src)
events = self.parse_events(stderr, dry_run=self.check_mode, nonzero_rc=rc != 0)
@ -682,32 +682,40 @@ class ServicesManager(BaseComposeManager):
def main():
argument_spec = dict(
state=dict(
type="str",
default="present",
choices=["absent", "present", "stopped", "restarted"],
),
dependencies=dict(type="bool", default=True),
pull=dict(
type="str",
choices=["always", "missing", "never", "policy"],
default="policy",
),
build=dict(type="str", choices=["always", "never", "policy"], default="policy"),
recreate=dict(type="str", default="auto", choices=["always", "never", "auto"]),
renew_anon_volumes=dict(type="bool", default=False),
remove_images=dict(type="str", choices=["all", "local"]),
remove_volumes=dict(type="bool", default=False),
remove_orphans=dict(type="bool", default=False),
timeout=dict(type="int"),
services=dict(type="list", elements="str"),
scale=dict(type="dict"),
wait=dict(type="bool", default=False),
wait_timeout=dict(type="int"),
ignore_build_events=dict(type="bool", default=True),
assume_yes=dict(type="bool", default=False),
)
argument_spec = {
"state": {
"type": "str",
"default": "present",
"choices": ["absent", "present", "stopped", "restarted"],
},
"dependencies": {"type": "bool", "default": True},
"pull": {
"type": "str",
"choices": ["always", "missing", "never", "policy"],
"default": "policy",
},
"build": {
"type": "str",
"choices": ["always", "never", "policy"],
"default": "policy",
},
"recreate": {
"type": "str",
"default": "auto",
"choices": ["always", "never", "auto"],
},
"renew_anon_volumes": {"type": "bool", "default": False},
"remove_images": {"type": "str", "choices": ["all", "local"]},
"remove_volumes": {"type": "bool", "default": False},
"remove_orphans": {"type": "bool", "default": False},
"timeout": {"type": "int"},
"services": {"type": "list", "elements": "str"},
"scale": {"type": "dict"},
"wait": {"type": "bool", "default": False},
"wait_timeout": {"type": "int"},
"ignore_build_events": {"type": "bool", "default": True},
"assume_yes": {"type": "bool", "default": False},
}
argspec_ex = common_compose_argspec_ex()
argument_spec.update(argspec_ex.pop("argspec"))

30
plugins/modules/docker_compose_v2_exec.py
View File

@ -263,21 +263,21 @@ class ExecManager(BaseComposeManager):
def main():
argument_spec = dict(
service=dict(type="str", required=True),
index=dict(type="int"),
argv=dict(type="list", elements="str"),
command=dict(type="str"),
chdir=dict(type="str"),
detach=dict(type="bool", default=False),
user=dict(type="str"),
stdin=dict(type="str"),
stdin_add_newline=dict(type="bool", default=True),
strip_empty_ends=dict(type="bool", default=True),
privileged=dict(type="bool", default=False),
tty=dict(type="bool", default=True),
env=dict(type="dict"),
)
argument_spec = {
"service": {"type": "str", "required": True},
"index": {"type": "int"},
"argv": {"type": "list", "elements": "str"},
"command": {"type": "str"},
"chdir": {"type": "str"},
"detach": {"type": "bool", "default": False},
"user": {"type": "str"},
"stdin": {"type": "str"},
"stdin_add_newline": {"type": "bool", "default": True},
"strip_empty_ends": {"type": "bool", "default": True},
"privileged": {"type": "bool", "default": False},
"tty": {"type": "bool", "default": True},
"env": {"type": "dict"},
}
argspec_ex = common_compose_argspec_ex()
argument_spec.update(argspec_ex.pop("argspec"))

18
plugins/modules/docker_compose_v2_pull.py
View File

@ -162,7 +162,7 @@ class PullManager(BaseComposeManager):
return args
def run(self):
result = dict()
result = {}
args = self.get_pull_cmd(self.check_mode)
rc, stdout, stderr = self.client.call_cli(*args, cwd=self.project_src)
events = self.parse_events(stderr, dry_run=self.check_mode, nonzero_rc=rc != 0)
@ -180,12 +180,16 @@ class PullManager(BaseComposeManager):
def main():
argument_spec = dict(
policy=dict(type="str", choices=["always", "missing"], default="always"),
ignore_buildable=dict(type="bool", default=False),
include_deps=dict(type="bool", default=False),
services=dict(type="list", elements="str"),
)
argument_spec = {
"policy": {
"type": "str",
"choices": ["always", "missing"],
"default": "always",
},
"ignore_buildable": {"type": "bool", "default": False},
"include_deps": {"type": "bool", "default": False},
"services": {"type": "list", "elements": "str"},
}
argspec_ex = common_compose_argspec_ex()
argument_spec.update(argspec_ex.pop("argspec"))

56
plugins/modules/docker_compose_v2_run.py
View File

@ -383,34 +383,34 @@ class ExecManager(BaseComposeManager):
def main():
argument_spec = dict(
service=dict(type="str", required=True),
argv=dict(type="list", elements="str"),
command=dict(type="str"),
build=dict(type="bool", default=False),
cap_add=dict(type="list", elements="str"),
cap_drop=dict(type="list", elements="str"),
entrypoint=dict(type="str"),
interactive=dict(type="bool", default=True),
labels=dict(type="list", elements="str"),
name=dict(type="str"),
no_deps=dict(type="bool", default=False),
publish=dict(type="list", elements="str"),
quiet_pull=dict(type="bool", default=False),
remove_orphans=dict(type="bool", default=False),
cleanup=dict(type="bool", default=False),
service_ports=dict(type="bool", default=False),
use_aliases=dict(type="bool", default=False),
volumes=dict(type="list", elements="str"),
chdir=dict(type="str"),
detach=dict(type="bool", default=False),
user=dict(type="str"),
stdin=dict(type="str"),
stdin_add_newline=dict(type="bool", default=True),
strip_empty_ends=dict(type="bool", default=True),
tty=dict(type="bool", default=True),
env=dict(type="dict"),
)
argument_spec = {
"service": {"type": "str", "required": True},
"argv": {"type": "list", "elements": "str"},
"command": {"type": "str"},
"build": {"type": "bool", "default": False},
"cap_add": {"type": "list", "elements": "str"},
"cap_drop": {"type": "list", "elements": "str"},
"entrypoint": {"type": "str"},
"interactive": {"type": "bool", "default": True},
"labels": {"type": "list", "elements": "str"},
"name": {"type": "str"},
"no_deps": {"type": "bool", "default": False},
"publish": {"type": "list", "elements": "str"},
"quiet_pull": {"type": "bool", "default": False},
"remove_orphans": {"type": "bool", "default": False},
"cleanup": {"type": "bool", "default": False},
"service_ports": {"type": "bool", "default": False},
"use_aliases": {"type": "bool", "default": False},
"volumes": {"type": "list", "elements": "str"},
"chdir": {"type": "str"},
"detach": {"type": "bool", "default": False},
"user": {"type": "str"},
"stdin": {"type": "str"},
"stdin_add_newline": {"type": "bool", "default": True},
"strip_empty_ends": {"type": "bool", "default": True},
"tty": {"type": "bool", "default": True},
"env": {"type": "dict"},
}
argspec_ex = common_compose_argspec_ex()
argument_spec.update(argspec_ex.pop("argspec"))

40
plugins/modules/docker_config.py
View File

@ -387,18 +387,22 @@ class ConfigManager(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
state=dict(type="str", default="present", choices=["absent", "present"]),
data=dict(type="str"),
data_is_b64=dict(type="bool", default=False),
data_src=dict(type="path"),
labels=dict(type="dict"),
force=dict(type="bool", default=False),
rolling_versions=dict(type="bool", default=False),
versions_to_keep=dict(type="int", default=5),
template_driver=dict(type="str", choices=["golang"]),
)
argument_spec = {
"name": {"type": "str", "required": True},
"state": {
"type": "str",
"default": "present",
"choices": ["absent", "present"],
},
"data": {"type": "str"},
"data_is_b64": {"type": "bool", "default": False},
"data_src": {"type": "path"},
"labels": {"type": "dict"},
"force": {"type": "bool", "default": False},
"rolling_versions": {"type": "bool", "default": False},
"versions_to_keep": {"type": "int", "default": 5},
"template_driver": {"type": "str", "choices": ["golang"]},
}
required_if = [
("state", "present", ["data", "data_src"], True),
@ -408,9 +412,9 @@ def main():
("data", "data_src"),
]
option_minimal_versions = dict(
template_driver=dict(docker_py_version="5.0.3", docker_api_version="1.37"),
)
option_minimal_versions = {
"template_driver": {"docker_py_version": "5.0.3", "docker_api_version": "1.37"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,
@ -424,9 +428,9 @@ def main():
sanitize_labels(client.module.params["labels"], "labels", client)
try:
results = dict(
changed=False,
)
results = {
"changed": False,
}
ConfigManager(client, results)()
client.module.exit_json(**results)

54
plugins/modules/docker_container_copy_into.py
View File

@ -752,10 +752,10 @@ def copy_file_into_container(
follow_links=local_follow_links,
)
result = dict(
container_path=container_path,
changed=changed,
)
result = {
"container_path": container_path,
"changed": changed,
}
if diff:
result["diff"] = diff
client.module.exit_json(**result)
@ -992,10 +992,10 @@ def copy_content_into_container(
mode=mode,
)
result = dict(
container_path=container_path,
changed=changed,
)
result = {
"container_path": container_path,
"changed": changed,
}
if diff:
# Since the content is no_log, make sure that the before/after strings look sufficiently different
key = generate_insecure_key()
@ -1022,26 +1022,26 @@ def parse_octal_string_only(mode):
def main():
argument_spec = dict(
container=dict(type="str", required=True),
path=dict(type="path"),
container_path=dict(type="str", required=True),
follow=dict(type="bool", default=False),
local_follow=dict(type="bool", default=True),
owner_id=dict(type="int"),
group_id=dict(type="int"),
mode=dict(type="raw"),
mode_parse=dict(
type="str",
choices=["legacy", "modern", "octal_string_only"],
default="legacy",
),
force=dict(type="bool"),
content=dict(type="str", no_log=True),
content_is_b64=dict(type="bool", default=False),
argument_spec = {
"container": {"type": "str", "required": True},
"path": {"type": "path"},
"container_path": {"type": "str", "required": True},
"follow": {"type": "bool", "default": False},
"local_follow": {"type": "bool", "default": True},
"owner_id": {"type": "int"},
"group_id": {"type": "int"},
"mode": {"type": "raw"},
"mode_parse": {
"type": "str",
"choices": ["legacy", "modern", "octal_string_only"],
"default": "legacy",
},
"force": {"type": "bool"},
"content": {"type": "str", "no_log": True},
"content_is_b64": {"type": "bool", "default": False},
# Undocumented parameters for use by the action plugin
_max_file_size_for_diff=dict(type="int"),
)
"_max_file_size_for_diff": {"type": "int"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

32
plugins/modules/docker_container_exec.py
View File

@ -187,23 +187,23 @@ from ansible_collections.community.docker.plugins.module_utils._socket_handler i
def main():
argument_spec = dict(
container=dict(type="str", required=True),
argv=dict(type="list", elements="str"),
command=dict(type="str"),
chdir=dict(type="str"),
detach=dict(type="bool", default=False),
user=dict(type="str"),
stdin=dict(type="str"),
stdin_add_newline=dict(type="bool", default=True),
strip_empty_ends=dict(type="bool", default=True),
tty=dict(type="bool", default=False),
env=dict(type="dict"),
)
argument_spec = {
"container": {"type": "str", "required": True},
"argv": {"type": "list", "elements": "str"},
"command": {"type": "str"},
"chdir": {"type": "str"},
"detach": {"type": "bool", "default": False},
"user": {"type": "str"},
"stdin": {"type": "str"},
"stdin_add_newline": {"type": "bool", "default": True},
"strip_empty_ends": {"type": "bool", "default": True},
"tty": {"type": "bool", "default": False},
"env": {"type": "dict"},
}
option_minimal_versions = dict(
chdir=dict(docker_api_version="1.35"),
)
option_minimal_versions = {
"chdir": {"docker_api_version": "1.35"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

6
plugins/modules/docker_container_info.py
View File

@ -87,9 +87,9 @@ from ansible_collections.community.docker.plugins.module_utils._common_api impor
def main():
argument_spec = dict(
name=dict(type="str", required=True),
)
argument_spec = {
"name": {"type": "str", "required": True},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

10
plugins/modules/docker_context_info.py
View File

@ -248,11 +248,11 @@ def context_to_json(context, current):
def main():
argument_spec = dict(
only_current=dict(type="bool", default=False),
name=dict(type="str"),
cli_context=dict(type="str"),
)
argument_spec = {
"only_current": {"type": "bool", "default": False},
"name": {"type": "str"},
"cli_context": {"type": "str"},
}
module = AnsibleModule(
argument_spec=argument_spec,

44
plugins/modules/docker_host_info.py
View File

@ -271,7 +271,7 @@ class DockerHostManager(DockerBaseClass):
try:
if self.verbose_output:
return self.client.df()
return dict(LayersSize=self.client.df()["LayersSize"])
return {"LayersSize": self.client.df()["LayersSize"]}
except APIError as exc:
self.client.fail(f"Error inspecting docker host: {exc}")
@ -292,7 +292,7 @@ class DockerHostManager(DockerBaseClass):
header_images = ["Id", "RepoTags", "Created", "Size"]
header_networks = ["Id", "Driver", "Name", "Scope"]
filter_arg = dict()
filter_arg = {}
if filters:
filter_arg["filters"] = filters
try:
@ -330,7 +330,7 @@ class DockerHostManager(DockerBaseClass):
return items
for item in items:
item_record = dict()
item_record = {}
if docker_object == "containers":
for key in header_containers:
@ -350,26 +350,26 @@ class DockerHostManager(DockerBaseClass):
def main():
argument_spec = dict(
containers=dict(type="bool", default=False),
containers_all=dict(type="bool", default=False),
containers_filters=dict(type="dict"),
images=dict(type="bool", default=False),
images_filters=dict(type="dict"),
networks=dict(type="bool", default=False),
networks_filters=dict(type="dict"),
volumes=dict(type="bool", default=False),
volumes_filters=dict(type="dict"),
disk_usage=dict(type="bool", default=False),
verbose_output=dict(type="bool", default=False),
)
argument_spec = {
"containers": {"type": "bool", "default": False},
"containers_all": {"type": "bool", "default": False},
"containers_filters": {"type": "dict"},
"images": {"type": "bool", "default": False},
"images_filters": {"type": "dict"},
"networks": {"type": "bool", "default": False},
"networks_filters": {"type": "dict"},
"volumes": {"type": "bool", "default": False},
"volumes_filters": {"type": "dict"},
"disk_usage": {"type": "bool", "default": False},
"verbose_output": {"type": "bool", "default": False},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,
supports_check_mode=True,
fail_results=dict(
can_talk_to_docker=False,
),
fail_results={
"can_talk_to_docker": False,
},
)
if (
client.module.params["api_version"] is None
@ -379,9 +379,9 @@ def main():
client.fail_results["can_talk_to_docker"] = True
try:
results = dict(
changed=False,
)
results = {
"changed": False,
}
DockerHostManager(client, results)
client.module.exit_json(**results)

132
plugins/modules/docker_image.py
View File

@ -442,8 +442,8 @@ class ImageManager(DockerBaseClass):
self.check_mode = self.client.check_mode
self.source = parameters["source"]
build = parameters["build"] or dict()
pull = parameters["pull"] or dict()
build = parameters["build"] or {}
pull = parameters["pull"] or {}
self.archive_path = parameters["archive_path"]
self.cache_from = build.get("cache_from")
self.container_limits = build.get("container_limits")
@ -796,7 +796,7 @@ class ImageManager(DockerBaseClass):
self.fail(f"Error pushing image {repository}: {exc}")
self.results["image"] = self.client.find_image(name=repository, tag=tag)
if not self.results["image"]:
self.results["image"] = dict()
self.results["image"] = {}
self.results["image"]["push_status"] = status
def tag_image(self, name, tag, repository, push=False):
@ -1079,54 +1079,58 @@ class ImageManager(DockerBaseClass):
def main():
argument_spec = dict(
source=dict(type="str", choices=["build", "load", "pull", "local"]),
build=dict(
type="dict",
options=dict(
cache_from=dict(type="list", elements="str"),
container_limits=dict(
type="dict",
options=dict(
memory=dict(type="str"),
memswap=dict(type="str"),
cpushares=dict(type="int"),
cpusetcpus=dict(type="str"),
),
),
dockerfile=dict(type="str"),
http_timeout=dict(type="int"),
network=dict(type="str"),
nocache=dict(type="bool", default=False),
path=dict(type="path", required=True),
pull=dict(type="bool", default=False),
rm=dict(type="bool", default=True),
args=dict(type="dict"),
use_config_proxy=dict(type="bool"),
target=dict(type="str"),
etc_hosts=dict(type="dict"),
platform=dict(type="str"),
shm_size=dict(type="str"),
labels=dict(type="dict"),
),
),
archive_path=dict(type="path"),
force_source=dict(type="bool", default=False),
force_absent=dict(type="bool", default=False),
force_tag=dict(type="bool", default=False),
load_path=dict(type="path"),
name=dict(type="str", required=True),
pull=dict(
type="dict",
options=dict(
platform=dict(type="str"),
),
),
push=dict(type="bool", default=False),
repository=dict(type="str"),
state=dict(type="str", default="present", choices=["absent", "present"]),
tag=dict(type="str", default="latest"),
)
argument_spec = {
"source": {"type": "str", "choices": ["build", "load", "pull", "local"]},
"build": {
"type": "dict",
"options": {
"cache_from": {"type": "list", "elements": "str"},
"container_limits": {
"type": "dict",
"options": {
"memory": {"type": "str"},
"memswap": {"type": "str"},
"cpushares": {"type": "int"},
"cpusetcpus": {"type": "str"},
},
},
"dockerfile": {"type": "str"},
"http_timeout": {"type": "int"},
"network": {"type": "str"},
"nocache": {"type": "bool", "default": False},
"path": {"type": "path", "required": True},
"pull": {"type": "bool", "default": False},
"rm": {"type": "bool", "default": True},
"args": {"type": "dict"},
"use_config_proxy": {"type": "bool"},
"target": {"type": "str"},
"etc_hosts": {"type": "dict"},
"platform": {"type": "str"},
"shm_size": {"type": "str"},
"labels": {"type": "dict"},
},
},
"archive_path": {"type": "path"},
"force_source": {"type": "bool", "default": False},
"force_absent": {"type": "bool", "default": False},
"force_tag": {"type": "bool", "default": False},
"load_path": {"type": "path"},
"name": {"type": "str", "required": True},
"pull": {
"type": "dict",
"options": {
"platform": {"type": "str"},
},
},
"push": {"type": "bool", "default": False},
"repository": {"type": "str"},
"state": {
"type": "str",
"default": "present",
"choices": ["absent", "present"],
},
"tag": {"type": "str", "default": "latest"},
}
required_if = [
("state", "present", ["source"]),
@ -1151,16 +1155,20 @@ def main():
and client.module.params["pull"].get("platform") is not None
)
option_minimal_versions = dict()
option_minimal_versions["build.etc_hosts"] = dict(
docker_api_version="1.27", detect_usage=detect_etc_hosts
)
option_minimal_versions["build.platform"] = dict(
docker_api_version="1.32", detect_usage=detect_build_platform
)
option_minimal_versions["pull.platform"] = dict(
docker_api_version="1.32", detect_usage=detect_pull_platform
)
option_minimal_versions = {
"build.etc_hosts": {
"docker_api_version": "1.27",
"detect_usage": detect_etc_hosts,
},
"build.platform": {
"docker_api_version": "1.32",
"detect_usage": detect_build_platform,
},
"pull.platform": {
"docker_api_version": "1.32",
"detect_usage": detect_pull_platform,
},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,
@ -1181,7 +1189,7 @@ def main():
)
try:
results = dict(changed=False, actions=[], image={})
results = {"changed": False, "actions": [], "image": {}}
ImageManager(client, results)
client.module.exit_json(**results)

110
plugins/modules/docker_image_build.py
View File

@ -514,11 +514,11 @@ class ImageBuilder(DockerBaseClass):
def build_image(self):
image = self.client.find_image(self.name, self.tag)
results = dict(
changed=False,
actions=[],
image=image or {},
)
results = {
"changed": False,
"actions": [],
"image": image or {},
}
if image:
if self.rebuild == "never":
@ -548,69 +548,73 @@ class ImageBuilder(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
tag=dict(type="str", default="latest"),
path=dict(type="path", required=True),
dockerfile=dict(type="str"),
cache_from=dict(type="list", elements="str"),
pull=dict(type="bool", default=False),
network=dict(type="str"),
nocache=dict(type="bool", default=False),
etc_hosts=dict(type="dict"),
args=dict(type="dict"),
target=dict(type="str"),
platform=dict(type="list", elements="str"),
shm_size=dict(type="str"),
labels=dict(type="dict"),
rebuild=dict(type="str", choices=["never", "always"], default="never"),
secrets=dict(
type="list",
elements="dict",
options=dict(
id=dict(type="str", required=True),
type=dict(type="str", choices=["file", "env", "value"], required=True),
src=dict(type="path"),
env=dict(type="str"),
value=dict(type="str", no_log=True),
),
required_if=[
argument_spec = {
"name": {"type": "str", "required": True},
"tag": {"type": "str", "default": "latest"},
"path": {"type": "path", "required": True},
"dockerfile": {"type": "str"},
"cache_from": {"type": "list", "elements": "str"},
"pull": {"type": "bool", "default": False},
"network": {"type": "str"},
"nocache": {"type": "bool", "default": False},
"etc_hosts": {"type": "dict"},
"args": {"type": "dict"},
"target": {"type": "str"},
"platform": {"type": "list", "elements": "str"},
"shm_size": {"type": "str"},
"labels": {"type": "dict"},
"rebuild": {"type": "str", "choices": ["never", "always"], "default": "never"},
"secrets": {
"type": "list",
"elements": "dict",
"options": {
"id": {"type": "str", "required": True},
"type": {
"type": "str",
"choices": ["file", "env", "value"],
"required": True,
},
"src": {"type": "path"},
"env": {"type": "str"},
"value": {"type": "str", "no_log": True},
},
"required_if": [
("type", "file", ["src"]),
("type", "env", ["env"]),
("type", "value", ["value"]),
],
mutually_exclusive=[
"mutually_exclusive": [
("src", "env", "value"),
],
no_log=False,
),
outputs=dict(
type="list",
elements="dict",
options=dict(
type=dict(
type="str",
choices=["local", "tar", "oci", "docker", "image"],
required=True,
),
dest=dict(type="path"),
context=dict(type="str"),
name=dict(type="list", elements="str"),
push=dict(type="bool", default=False),
),
required_if=[
"no_log": False,
},
"outputs": {
"type": "list",
"elements": "dict",
"options": {
"type": {
"type": "str",
"choices": ["local", "tar", "oci", "docker", "image"],
"required": True,
},
"dest": {"type": "path"},
"context": {"type": "str"},
"name": {"type": "list", "elements": "str"},
"push": {"type": "bool", "default": False},
},
"required_if": [
("type", "local", ["dest"]),
("type", "tar", ["dest"]),
("type", "oci", ["dest"]),
],
mutually_exclusive=[
"mutually_exclusive": [
("dest", "name"),
("dest", "push"),
("context", "name"),
("context", "push"),
],
),
)
},
}
client = AnsibleModuleDockerClient(
argument_spec=argument_spec,

17
plugins/modules/docker_image_export.py
View File

@ -261,12 +261,17 @@ class ImageExportManager(DockerBaseClass):
def main():
argument_spec = dict(
path=dict(type="path"),
force=dict(type="bool", default=False),
names=dict(type="list", elements="str", required=True, aliases=["name"]),
tag=dict(type="str", default="latest"),
)
argument_spec = {
"path": {"type": "path"},
"force": {"type": "bool", "default": False},
"names": {
"type": "list",
"elements": "str",
"required": True,
"aliases": ["name"],
},
"tag": {"type": "str", "default": "latest"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

8
plugins/modules/docker_image_info.py
View File

@ -219,9 +219,9 @@ class ImageManager(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="list", elements="str"),
)
argument_spec = {
"name": {"type": "list", "elements": "str"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,
@ -229,7 +229,7 @@ def main():
)
try:
results = dict(changed=False, images=[])
results = {"changed": False, "images": []}
ImageManager(client, results)
client.module.exit_json(**results)

14
plugins/modules/docker_image_load.py
View File

@ -181,17 +181,17 @@ class ImageManager(DockerBaseClass):
def main():
client = AnsibleDockerClient(
argument_spec=dict(
path=dict(type="path", required=True),
),
argument_spec={
"path": {"type": "path", "required": True},
},
supports_check_mode=False,
)
try:
results = dict(
image_names=[],
images=[],
)
results = {
"image_names": [],
"images": [],
}
ImageManager(client, results)
client.module.exit_json(**results)

36
plugins/modules/docker_image_pull.py
View File

@ -149,12 +149,12 @@ class ImagePuller(DockerBaseClass):
def pull(self):
image = self.client.find_image(name=self.name, tag=self.tag)
results = dict(
changed=False,
actions=[],
image=image or {},
diff=dict(before=image_info(image), after=image_info(image)),
)
results = {
"changed": False,
"actions": [],
"image": image or {},
"diff": {"before": image_info(image), "after": image_info(image)},
}
if image and self.pull_mode == "not_present":
if self.platform is None:
@ -178,7 +178,7 @@ class ImagePuller(DockerBaseClass):
results["actions"].append(f"Pulled image {self.name}:{self.tag}")
if self.check_mode:
results["changed"] = True
results["diff"]["after"] = image_info(dict(Id="unknown"))
results["diff"]["after"] = image_info({"Id": "unknown"})
else:
results["image"], not_changed = self.client.pull_image(
self.name, tag=self.tag, image_platform=self.platform
@ -190,16 +190,20 @@ class ImagePuller(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
tag=dict(type="str", default="latest"),
platform=dict(type="str"),
pull=dict(type="str", choices=["always", "not_present"], default="always"),
)
argument_spec = {
"name": {"type": "str", "required": True},
"tag": {"type": "str", "default": "latest"},
"platform": {"type": "str"},
"pull": {
"type": "str",
"choices": ["always", "not_present"],
"default": "always",
},
}
option_minimal_versions = dict(
platform=dict(docker_api_version="1.32"),
)
option_minimal_versions = {
"platform": {"docker_api_version": "1.32"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

18
plugins/modules/docker_image_push.py
View File

@ -127,11 +127,11 @@ class ImagePusher(DockerBaseClass):
if not image:
self.client.fail(f"Cannot find image {self.name}:{self.tag}")
results = dict(
changed=False,
actions=[],
image=image,
)
results = {
"changed": False,
"actions": [],
"image": image,
}
push_registry, push_repo = resolve_repository_name(self.name)
try:
@ -175,10 +175,10 @@ class ImagePusher(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
tag=dict(type="str", default="latest"),
)
argument_spec = {
"name": {"type": "str", "required": True},
"tag": {"type": "str", "default": "latest"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

42
plugins/modules/docker_image_remove.py
View File

@ -147,22 +147,22 @@ class ImageRemover(DockerBaseClass):
def get_diff_state(self, image):
if not image:
return dict(exists=False)
return dict(
exists=True,
id=image["Id"],
tags=sorted(image.get("RepoTags") or []),
digests=sorted(image.get("RepoDigests") or []),
)
return {"exists": False}
return {
"exists": True,
"id": image["Id"],
"tags": sorted(image.get("RepoTags") or []),
"digests": sorted(image.get("RepoDigests") or []),
}
def absent(self):
results = dict(
changed=False,
actions=[],
image={},
deleted=[],
untagged=[],
)
results = {
"changed": False,
"actions": [],
"image": {},
"deleted": [],
"untagged": [],
}
name = self.name
if is_image_name_id(name):
@ -173,7 +173,7 @@ class ImageRemover(DockerBaseClass):
name = f"{self.name}:{self.tag}"
if self.diff:
results["diff"] = dict(before=self.get_diff_state(image))
results["diff"] = {"before": self.get_diff_state(image)}
if not image:
if self.diff:
@ -256,12 +256,12 @@ class ImageRemover(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
tag=dict(type="str", default="latest"),
force=dict(type="bool", default=False),
prune=dict(type="bool", default=True),
)
argument_spec = {
"name": {"type": "str", "required": True},
"tag": {"type": "str", "default": "latest"},
"force": {"type": "bool", "default": False},
"prune": {"type": "bool", "default": True},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

34
plugins/modules/docker_image_tag.py
View File

@ -133,7 +133,7 @@ def convert_to_bytes(value, module, name, unlimited_value=None):
def image_info(name, tag, image):
result = dict(name=name, tag=tag)
result = {"name": name, "tag": tag}
if image:
result["id"] = image["Id"]
else:
@ -231,13 +231,13 @@ class ImageTagger(DockerBaseClass):
before = []
after = []
tagged_images = []
results = dict(
changed=False,
actions=[],
image=image,
tagged_images=tagged_images,
diff=dict(before=dict(images=before), after=dict(images=after)),
)
results = {
"changed": False,
"actions": [],
"image": image,
"tagged_images": tagged_images,
"diff": {"before": {"images": before}, "after": {"images": after}},
}
for repository, tag in self.repositories:
tagged, msg, old_image = self.tag_image(image, repository, tag)
before.append(image_info(repository, tag, old_image))
@ -257,14 +257,16 @@ class ImageTagger(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
tag=dict(type="str", default="latest"),
repository=dict(type="list", elements="str", required=True),
existing_images=dict(
type="str", choices=["keep", "overwrite"], default="overwrite"
),
)
argument_spec = {
"name": {"type": "str", "required": True},
"tag": {"type": "str", "default": "latest"},
"repository": {"type": "list", "elements": "str", "required": True},
"existing_images": {
"type": "str",
"choices": ["keep", "overwrite"],
"default": "overwrite",
},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

46
plugins/modules/docker_login.py
View File

@ -158,7 +158,7 @@ class DockerFileStore:
self._config_path = config_path
# Make sure we have a minimal config if none is available.
self._config = dict(auths=dict())
self._config = {"auths": {}}
try:
# Attempt to read the existing config.
@ -166,7 +166,7 @@ class DockerFileStore:
config = json.load(f)
except (ValueError, IOError):
# No config found or an invalid config found so we'll ignore it.
config = dict()
config = {}
# Update our internal config with what ever was loaded.
self._config.update(config)
@ -191,7 +191,7 @@ class DockerFileStore:
(username, password) = decode_auth(server_creds["auth"])
return dict(Username=username, Secret=password)
return {"Username": username, "Secret": password}
def _write(self):
"""
@ -219,9 +219,9 @@ class DockerFileStore:
# build up the auth structure
if "auths" not in self._config:
self._config["auths"] = dict()
self._config["auths"] = {}
self._config["auths"][server] = dict(auth=tauth)
self._config["auths"][server] = {"auth": tauth}
self._write()
@ -368,7 +368,7 @@ class LoginManager(DockerBaseClass):
current = store.get(self.registry_url)
except CredentialsNotFound:
# get raises an exception on not found.
current = dict(Username="", Secret="")
current = {"Username": "", "Secret": ""}
if (
current["Username"] != self.username
@ -410,18 +410,26 @@ class LoginManager(DockerBaseClass):
def main():
argument_spec = dict(
registry_url=dict(
type="str", default=DEFAULT_DOCKER_REGISTRY, aliases=["registry", "url"]
),
username=dict(type="str"),
password=dict(type="str", no_log=True),
reauthorize=dict(type="bool", default=False, aliases=["reauth"]),
state=dict(type="str", default="present", choices=["present", "absent"]),
config_path=dict(
type="path", default="~/.docker/config.json", aliases=["dockercfg_path"]
),
)
argument_spec = {
"registry_url": {
"type": "str",
"default": DEFAULT_DOCKER_REGISTRY,
"aliases": ["registry", "url"],
},
"username": {"type": "str"},
"password": {"type": "str", "no_log": True},
"reauthorize": {"type": "bool", "default": False, "aliases": ["reauth"]},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "absent"],
},
"config_path": {
"type": "path",
"default": "~/.docker/config.json",
"aliases": ["dockercfg_path"],
},
}
required_if = [
("state", "present", ["username", "password"]),
@ -434,7 +442,7 @@ def main():
)
try:
results = dict(changed=False, actions=[], login_result={})
results = {"changed": False, "actions": [], "login_result": {}}
manager = LoginManager(client, results)
manager.run()

91
plugins/modules/docker_network.py
View File

@ -395,7 +395,7 @@ class DockerNetworkManager:
self.results = {"changed": False, "actions": []}
self.diff = self.client.module._diff
self.diff_tracker = DifferenceTracker()
self.diff_result = dict()
self.diff_result = {}
self.existing_network = self.get_existing_network()
@ -511,13 +511,13 @@ class DockerNetworkManager:
# Put network's IPAM config into the same format as module's IPAM config
net_ipam_configs = []
for net_ipam_config in net["IPAM"]["Config"]:
config = dict()
config = {}
for k, v in net_ipam_config.items():
config[normalize_ipam_config_key(k)] = v
net_ipam_configs.append(config)
# Compare lists of dicts as sets of dicts
for idx, ipam_config in enumerate(self.parameters.ipam_config):
net_config = dict()
net_config = {}
for net_ipam_config in net_ipam_configs:
if dicts_are_essentially_equal(ipam_config, net_ipam_config):
net_config = net_ipam_config
@ -779,45 +779,54 @@ class DockerNetworkManager:
def main():
argument_spec = dict(
name=dict(type="str", required=True, aliases=["network_name"]),
config_from=dict(type="str"),
config_only=dict(type="bool"),
connected=dict(type="list", default=[], elements="str", aliases=["containers"]),
state=dict(type="str", default="present", choices=["present", "absent"]),
driver=dict(type="str", default="bridge"),
driver_options=dict(type="dict", default={}),
force=dict(type="bool", default=False),
appends=dict(type="bool", default=False, aliases=["incremental"]),
ipam_driver=dict(type="str"),
ipam_driver_options=dict(type="dict"),
ipam_config=dict(
type="list",
elements="dict",
options=dict(
subnet=dict(type="str"),
iprange=dict(type="str"),
gateway=dict(type="str"),
aux_addresses=dict(type="dict"),
),
),
enable_ipv4=dict(type="bool"),
enable_ipv6=dict(type="bool"),
internal=dict(type="bool"),
labels=dict(type="dict", default={}),
debug=dict(type="bool", default=False),
scope=dict(type="str", choices=["local", "global", "swarm"]),
attachable=dict(type="bool"),
ingress=dict(type="bool"),
)
argument_spec = {
"name": {"type": "str", "required": True, "aliases": ["network_name"]},
"config_from": {"type": "str"},
"config_only": {"type": "bool"},
"connected": {
"type": "list",
"default": [],
"elements": "str",
"aliases": ["containers"],
},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "absent"],
},
"driver": {"type": "str", "default": "bridge"},
"driver_options": {"type": "dict", "default": {}},
"force": {"type": "bool", "default": False},
"appends": {"type": "bool", "default": False, "aliases": ["incremental"]},
"ipam_driver": {"type": "str"},
"ipam_driver_options": {"type": "dict"},
"ipam_config": {
"type": "list",
"elements": "dict",
"options": {
"subnet": {"type": "str"},
"iprange": {"type": "str"},
"gateway": {"type": "str"},
"aux_addresses": {"type": "dict"},
},
},
"enable_ipv4": {"type": "bool"},
"enable_ipv6": {"type": "bool"},
"internal": {"type": "bool"},
"labels": {"type": "dict", "default": {}},
"debug": {"type": "bool", "default": False},
"scope": {"type": "str", "choices": ["local", "global", "swarm"]},
"attachable": {"type": "bool"},
"ingress": {"type": "bool"},
}
option_minimal_versions = dict(
config_from=dict(docker_api_version="1.30"),
config_only=dict(docker_api_version="1.30"),
scope=dict(docker_api_version="1.30"),
attachable=dict(docker_api_version="1.26"),
enable_ipv4=dict(docker_api_version="1.47"),
)
option_minimal_versions = {
"config_from": {"docker_api_version": "1.30"},
"config_only": {"docker_api_version": "1.30"},
"scope": {"docker_api_version": "1.30"},
"attachable": {"docker_api_version": "1.26"},
"enable_ipv4": {"docker_api_version": "1.47"},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

6
plugins/modules/docker_network_info.py
View File

@ -108,9 +108,9 @@ from ansible_collections.community.docker.plugins.module_utils._common_api impor
def main():
argument_spec = dict(
name=dict(type="str", required=True),
)
argument_spec = {
"name": {"type": "str", "required": True},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

36
plugins/modules/docker_node.py
View File

@ -206,11 +206,11 @@ class SwarmNodeManager(DockerBaseClass):
self.client.fail(f"Failed to get node information for {exc}")
changed = False
node_spec = dict(
Availability=self.parameters.availability,
Role=self.parameters.role,
Labels=self.parameters.labels,
)
node_spec = {
"Availability": self.parameters.availability,
"Role": self.parameters.role,
"Labels": self.parameters.labels,
}
if self.parameters.role is None:
node_spec["Role"] = node_info["Spec"]["Role"]
@ -278,14 +278,18 @@ class SwarmNodeManager(DockerBaseClass):
def main():
argument_spec = dict(
hostname=dict(type="str", required=True),
labels=dict(type="dict"),
labels_state=dict(type="str", default="merge", choices=["merge", "replace"]),
labels_to_remove=dict(type="list", elements="str"),
availability=dict(type="str", choices=["active", "pause", "drain"]),
role=dict(type="str", choices=["worker", "manager"]),
)
argument_spec = {
"hostname": {"type": "str", "required": True},
"labels": {"type": "dict"},
"labels_state": {
"type": "str",
"default": "merge",
"choices": ["merge", "replace"],
},
"labels_to_remove": {"type": "list", "elements": "str"},
"availability": {"type": "str", "choices": ["active", "pause", "drain"]},
"role": {"type": "str", "choices": ["worker", "manager"]},
}
client = AnsibleDockerSwarmClient(
argument_spec=argument_spec,
@ -294,9 +298,9 @@ def main():
)
try:
results = dict(
changed=False,
)
results = {
"changed": False,
}
SwarmNodeManager(client, results)
client.module.exit_json(**results)

8
plugins/modules/docker_node_info.py
View File

@ -131,10 +131,10 @@ def get_node_facts(client):
def main():
argument_spec = dict(
name=dict(type="list", elements="str"),
self=dict(type="bool", default=False),
)
argument_spec = {
"name": {"type": "list", "elements": "str"},
"self": {"type": "bool", "default": False},
}
client = AnsibleDockerSwarmClient(
argument_spec=argument_spec,

28
plugins/modules/docker_plugin.py
View File

@ -185,7 +185,7 @@ class DockerPluginManager:
self.check_mode = self.client.check_mode
self.diff = self.client.module._diff
self.diff_tracker = DifferenceTracker()
self.diff_result = dict()
self.diff_result = {}
self.actions = []
self.changed = False
@ -416,19 +416,19 @@ class DockerPluginManager:
def main():
argument_spec = dict(
alias=dict(type="str"),
plugin_name=dict(type="str", required=True),
state=dict(
type="str",
default="present",
choices=["present", "absent", "enable", "disable"],
),
plugin_options=dict(type="dict", default={}),
debug=dict(type="bool", default=False),
force_remove=dict(type="bool", default=False),
enable_timeout=dict(type="int", default=0),
)
argument_spec = {
"alias": {"type": "str"},
"plugin_name": {"type": "str", "required": True},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "absent", "enable", "disable"],
},
"plugin_options": {"type": "dict", "default": {}},
"debug": {"type": "bool", "default": False},
"force_remove": {"type": "bool", "default": False},
"enable_timeout": {"type": "int", "default": 0},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,
supports_check_mode=True,

42
plugins/modules/docker_prune.py
View File

@ -248,29 +248,29 @@ from ansible_collections.community.docker.plugins.module_utils._util import (
def main():
argument_spec = dict(
containers=dict(type="bool", default=False),
containers_filters=dict(type="dict"),
images=dict(type="bool", default=False),
images_filters=dict(type="dict"),
networks=dict(type="bool", default=False),
networks_filters=dict(type="dict"),
volumes=dict(type="bool", default=False),
volumes_filters=dict(type="dict"),
builder_cache=dict(type="bool", default=False),
builder_cache_all=dict(type="bool", default=False),
builder_cache_filters=dict(type="dict"),
builder_cache_keep_storage=dict(type="str"), # convert to bytes
)
argument_spec = {
"containers": {"type": "bool", "default": False},
"containers_filters": {"type": "dict"},
"images": {"type": "bool", "default": False},
"images_filters": {"type": "dict"},
"networks": {"type": "bool", "default": False},
"networks_filters": {"type": "dict"},
"volumes": {"type": "bool", "default": False},
"volumes_filters": {"type": "dict"},
"builder_cache": {"type": "bool", "default": False},
"builder_cache_all": {"type": "bool", "default": False},
"builder_cache_filters": {"type": "dict"},
"builder_cache_keep_storage": {"type": "str"}, # convert to bytes
}
client = AnsibleDockerClient(
argument_spec=argument_spec,
option_minimal_versions=dict(
builder_cache=dict(docker_py_version="1.31"),
builder_cache_all=dict(docker_py_version="1.39"),
builder_cache_filters=dict(docker_py_version="1.31"),
builder_cache_keep_storage=dict(docker_py_version="1.39"),
),
option_minimal_versions={
"builder_cache": {"docker_py_version": "1.31"},
"builder_cache_all": {"docker_py_version": "1.39"},
"builder_cache_filters": {"docker_py_version": "1.31"},
"builder_cache_keep_storage": {"docker_py_version": "1.39"},
},
# supports_check_mode=True,
)
@ -286,7 +286,7 @@ def main():
)
try:
result = dict()
result = {}
changed = False
if client.module.params["containers"]:

28
plugins/modules/docker_secret.py
View File

@ -366,17 +366,21 @@ class SecretManager(DockerBaseClass):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
state=dict(type="str", default="present", choices=["absent", "present"]),
data=dict(type="str", no_log=True),
data_is_b64=dict(type="bool", default=False),
data_src=dict(type="path"),
labels=dict(type="dict"),
force=dict(type="bool", default=False),
rolling_versions=dict(type="bool", default=False),
versions_to_keep=dict(type="int", default=5),
)
argument_spec = {
"name": {"type": "str", "required": True},
"state": {
"type": "str",
"default": "present",
"choices": ["absent", "present"],
},
"data": {"type": "str", "no_log": True},
"data_is_b64": {"type": "bool", "default": False},
"data_src": {"type": "path"},
"labels": {"type": "dict"},
"force": {"type": "bool", "default": False},
"rolling_versions": {"type": "bool", "default": False},
"versions_to_keep": {"type": "int", "default": 5},
}
required_if = [
("state", "present", ["data", "data_src"], True),
@ -396,7 +400,7 @@ def main():
sanitize_labels(client.module.params["labels"], "labels", client)
try:
results = dict(changed=False, secret_id="", secret_name="")
results = {"changed": False, "secret_id": "", "secret_name": ""}
SecretManager(client, results)()
client.module.exit_json(**results)

22
plugins/modules/docker_stack.py
View File

@ -240,15 +240,19 @@ def docker_stack_rm(client, stack_name, retries, interval):
def main():
client = AnsibleModuleDockerClient(
argument_spec={
"name": dict(type="str", required=True),
"compose": dict(type="list", elements="raw", default=[]),
"prune": dict(type="bool", default=False),
"detach": dict(type="bool", default=True),
"with_registry_auth": dict(type="bool", default=False),
"resolve_image": dict(type="str", choices=["always", "changed", "never"]),
"state": dict(type="str", default="present", choices=["present", "absent"]),
"absent_retries": dict(type="int", default=0),
"absent_retries_interval": dict(type="int", default=1),
"name": {"type": "str", "required": True},
"compose": {"type": "list", "elements": "raw", "default": []},
"prune": {"type": "bool", "default": False},
"detach": {"type": "bool", "default": True},
"with_registry_auth": {"type": "bool", "default": False},
"resolve_image": {"type": "str", "choices": ["always", "changed", "never"]},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "absent"],
},
"absent_retries": {"type": "int", "default": 0},
"absent_retries_interval": {"type": "int", "default": 1},
},
supports_check_mode=False,
)

2
plugins/modules/docker_stack_task_info.py
View File

@ -104,7 +104,7 @@ def docker_stack_task(module, stack_name):
def main():
client = AnsibleModuleDockerClient(
argument_spec={"name": dict(type="str", required=True)},
argument_spec={"name": {"type": "str", "required": True}},
supports_check_mode=True,
)

153
plugins/modules/docker_swarm.py
View File

@ -359,17 +359,17 @@ class TaskParameters(DockerBaseClass):
def update_from_swarm_info(self, swarm_info):
spec = swarm_info["Spec"]
ca_config = spec.get("CAConfig") or dict()
ca_config = spec.get("CAConfig") or {}
if self.node_cert_expiry is None:
self.node_cert_expiry = ca_config.get("NodeCertExpiry")
if self.ca_force_rotate is None:
self.ca_force_rotate = ca_config.get("ForceRotate")
dispatcher = spec.get("Dispatcher") or dict()
dispatcher = spec.get("Dispatcher") or {}
if self.dispatcher_heartbeat_period is None:
self.dispatcher_heartbeat_period = dispatcher.get("HeartbeatPeriod")
raft = spec.get("Raft") or dict()
raft = spec.get("Raft") or {}
if self.snapshot_interval is None:
self.snapshot_interval = raft.get("SnapshotInterval")
if self.keep_old_snapshots is None:
@ -381,13 +381,13 @@ class TaskParameters(DockerBaseClass):
if self.election_tick is None:
self.election_tick = raft.get("ElectionTick")
orchestration = spec.get("Orchestration") or dict()
orchestration = spec.get("Orchestration") or {}
if self.task_history_retention_limit is None:
self.task_history_retention_limit = orchestration.get(
"TaskHistoryRetentionLimit"
)
encryption_config = spec.get("EncryptionConfig") or dict()
encryption_config = spec.get("EncryptionConfig") or {}
if self.autolock_managers is None:
self.autolock_managers = encryption_config.get("AutoLockManagers")
@ -401,24 +401,24 @@ class TaskParameters(DockerBaseClass):
self.log_driver = spec["TaskDefaults"]["LogDriver"]
def update_parameters(self, client):
assign = dict(
snapshot_interval="snapshot_interval",
task_history_retention_limit="task_history_retention_limit",
keep_old_snapshots="keep_old_snapshots",
log_entries_for_slow_followers="log_entries_for_slow_followers",
heartbeat_tick="heartbeat_tick",
election_tick="election_tick",
dispatcher_heartbeat_period="dispatcher_heartbeat_period",
node_cert_expiry="node_cert_expiry",
name="name",
labels="labels",
signing_ca_cert="signing_ca_cert",
signing_ca_key="signing_ca_key",
ca_force_rotate="ca_force_rotate",
autolock_managers="autolock_managers",
log_driver="log_driver",
)
params = dict()
assign = {
"snapshot_interval": "snapshot_interval",
"task_history_retention_limit": "task_history_retention_limit",
"keep_old_snapshots": "keep_old_snapshots",
"log_entries_for_slow_followers": "log_entries_for_slow_followers",
"heartbeat_tick": "heartbeat_tick",
"election_tick": "election_tick",
"dispatcher_heartbeat_period": "dispatcher_heartbeat_period",
"node_cert_expiry": "node_cert_expiry",
"name": "name",
"labels": "labels",
"signing_ca_cert": "signing_ca_cert",
"signing_ca_key": "signing_ca_key",
"ca_force_rotate": "ca_force_rotate",
"autolock_managers": "autolock_managers",
"log_driver": "log_driver",
}
params = {}
for dest, source in assign.items():
if not client.option_minimal_versions[source]["supported"]:
continue
@ -489,7 +489,7 @@ class SwarmManager(DockerBaseClass):
choice_map.get(self.state)()
if self.client.module._diff or self.parameters.debug:
diff = dict()
diff = {}
diff["before"], diff["after"] = self.differences.get_before_after()
self.results["diff"] = diff
@ -660,62 +660,65 @@ def _detect_remove_operation(client):
def main():
argument_spec = dict(
advertise_addr=dict(type="str"),
data_path_addr=dict(type="str"),
data_path_port=dict(type="int"),
state=dict(
type="str",
default="present",
choices=["present", "join", "absent", "remove"],
),
force=dict(type="bool", default=False),
listen_addr=dict(type="str", default="0.0.0.0:2377"),
remote_addrs=dict(type="list", elements="str"),
join_token=dict(type="str", no_log=True),
snapshot_interval=dict(type="int"),
task_history_retention_limit=dict(type="int"),
keep_old_snapshots=dict(type="int"),
log_entries_for_slow_followers=dict(type="int"),
heartbeat_tick=dict(type="int"),
election_tick=dict(type="int"),
dispatcher_heartbeat_period=dict(type="int"),
node_cert_expiry=dict(type="int"),
name=dict(type="str"),
labels=dict(type="dict"),
signing_ca_cert=dict(type="str"),
signing_ca_key=dict(type="str", no_log=True),
ca_force_rotate=dict(type="int"),
autolock_managers=dict(type="bool"),
node_id=dict(type="str"),
rotate_worker_token=dict(type="bool", default=False),
rotate_manager_token=dict(type="bool", default=False),
default_addr_pool=dict(type="list", elements="str"),
subnet_size=dict(type="int"),
)
argument_spec = {
"advertise_addr": {"type": "str"},
"data_path_addr": {"type": "str"},
"data_path_port": {"type": "int"},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "join", "absent", "remove"],
},
"force": {"type": "bool", "default": False},
"listen_addr": {"type": "str", "default": "0.0.0.0:2377"},
"remote_addrs": {"type": "list", "elements": "str"},
"join_token": {"type": "str", "no_log": True},
"snapshot_interval": {"type": "int"},
"task_history_retention_limit": {"type": "int"},
"keep_old_snapshots": {"type": "int"},
"log_entries_for_slow_followers": {"type": "int"},
"heartbeat_tick": {"type": "int"},
"election_tick": {"type": "int"},
"dispatcher_heartbeat_period": {"type": "int"},
"node_cert_expiry": {"type": "int"},
"name": {"type": "str"},
"labels": {"type": "dict"},
"signing_ca_cert": {"type": "str"},
"signing_ca_key": {"type": "str", "no_log": True},
"ca_force_rotate": {"type": "int"},
"autolock_managers": {"type": "bool"},
"node_id": {"type": "str"},
"rotate_worker_token": {"type": "bool", "default": False},
"rotate_manager_token": {"type": "bool", "default": False},
"default_addr_pool": {"type": "list", "elements": "str"},
"subnet_size": {"type": "int"},
}
required_if = [
("state", "join", ["remote_addrs", "join_token"]),
("state", "remove", ["node_id"]),
]
option_minimal_versions = dict(
labels=dict(docker_py_version="2.6.0", docker_api_version="1.32"),
signing_ca_cert=dict(docker_py_version="2.6.0", docker_api_version="1.30"),
signing_ca_key=dict(docker_py_version="2.6.0", docker_api_version="1.30"),
ca_force_rotate=dict(docker_py_version="2.6.0", docker_api_version="1.30"),
autolock_managers=dict(docker_py_version="2.6.0"),
log_driver=dict(docker_py_version="2.6.0"),
remove_operation=dict(
docker_py_version="2.4.0",
detect_usage=_detect_remove_operation,
usage_msg="remove swarm nodes",
),
default_addr_pool=dict(docker_py_version="4.0.0", docker_api_version="1.39"),
subnet_size=dict(docker_py_version="4.0.0", docker_api_version="1.39"),
data_path_addr=dict(docker_py_version="4.0.0", docker_api_version="1.30"),
data_path_port=dict(docker_py_version="6.0.0", docker_api_version="1.40"),
)
option_minimal_versions = {
"labels": {"docker_py_version": "2.6.0", "docker_api_version": "1.32"},
"signing_ca_cert": {"docker_py_version": "2.6.0", "docker_api_version": "1.30"},
"signing_ca_key": {"docker_py_version": "2.6.0", "docker_api_version": "1.30"},
"ca_force_rotate": {"docker_py_version": "2.6.0", "docker_api_version": "1.30"},
"autolock_managers": {"docker_py_version": "2.6.0"},
"log_driver": {"docker_py_version": "2.6.0"},
"remove_operation": {
"docker_py_version": "2.4.0",
"detect_usage": _detect_remove_operation,
"usage_msg": "remove swarm nodes",
},
"default_addr_pool": {
"docker_py_version": "4.0.0",
"docker_api_version": "1.39",
},
"subnet_size": {"docker_py_version": "4.0.0", "docker_api_version": "1.39"},
"data_path_addr": {"docker_py_version": "4.0.0", "docker_api_version": "1.30"},
"data_path_port": {"docker_py_version": "6.0.0", "docker_api_version": "1.40"},
}
client = AnsibleDockerSwarmClient(
argument_spec=argument_spec,
@ -727,7 +730,7 @@ def main():
sanitize_labels(client.module.params["labels"], "labels", client)
try:
results = dict(changed=False, result="", actions=[])
results = {"changed": False, "result": "", "actions": []}
SwarmManager(client, results)()
client.module.exit_json(**results)

50
plugins/modules/docker_swarm_info.py
View File

@ -261,7 +261,7 @@ class DockerSwarmManager(DockerBaseClass):
return items
for item in items:
item_record = dict()
item_record = {}
if docker_object == "nodes":
item_record = self.get_essential_facts_nodes(item)
@ -277,7 +277,7 @@ class DockerSwarmManager(DockerBaseClass):
@staticmethod
def get_essential_facts_nodes(item):
object_essentials = dict()
object_essentials = {}
object_essentials["ID"] = item.get("ID")
object_essentials["Hostname"] = item["Description"]["Hostname"]
@ -299,7 +299,7 @@ class DockerSwarmManager(DockerBaseClass):
return object_essentials
def get_essential_facts_tasks(self, item):
object_essentials = dict()
object_essentials = {}
object_essentials["ID"] = item["ID"]
# Returning container ID to not trigger another connection to host
@ -320,7 +320,7 @@ class DockerSwarmManager(DockerBaseClass):
@staticmethod
def get_essential_facts_services(item):
object_essentials = dict()
object_essentials = {}
object_essentials["ID"] = item["ID"]
object_essentials["Name"] = item["Spec"]["Name"]
@ -349,39 +349,39 @@ class DockerSwarmManager(DockerBaseClass):
def main():
argument_spec = dict(
nodes=dict(type="bool", default=False),
nodes_filters=dict(type="dict"),
tasks=dict(type="bool", default=False),
tasks_filters=dict(type="dict"),
services=dict(type="bool", default=False),
services_filters=dict(type="dict"),
unlock_key=dict(type="bool", default=False),
verbose_output=dict(type="bool", default=False),
)
option_minimal_versions = dict(
unlock_key=dict(docker_py_version="2.7.0"),
)
argument_spec = {
"nodes": {"type": "bool", "default": False},
"nodes_filters": {"type": "dict"},
"tasks": {"type": "bool", "default": False},
"tasks_filters": {"type": "dict"},
"services": {"type": "bool", "default": False},
"services_filters": {"type": "dict"},
"unlock_key": {"type": "bool", "default": False},
"verbose_output": {"type": "bool", "default": False},
}
option_minimal_versions = {
"unlock_key": {"docker_py_version": "2.7.0"},
}
client = AnsibleDockerSwarmClient(
argument_spec=argument_spec,
supports_check_mode=True,
min_docker_version="1.10.0",
option_minimal_versions=option_minimal_versions,
fail_results=dict(
can_talk_to_docker=False,
docker_swarm_active=False,
docker_swarm_manager=False,
),
fail_results={
"can_talk_to_docker": False,
"docker_swarm_active": False,
"docker_swarm_manager": False,
},
)
client.fail_results["can_talk_to_docker"] = True
client.fail_results["docker_swarm_active"] = client.check_if_swarm_node()
client.fail_results["docker_swarm_manager"] = client.check_if_swarm_manager()
try:
results = dict(
changed=False,
)
results = {
"changed": False,
}
DockerSwarmManager(client, results)
results.update(client.fail_results)

620
plugins/modules/docker_swarm_service.py
View File

@ -1019,9 +1019,9 @@ def has_dict_changed(new_dict, old_dict):
return True
if not old_dict and new_dict:
return True
defined_options = dict(
(option, value) for option, value in new_dict.items() if value is not None
)
defined_options = {
option: value for option, value in new_dict.items() if value is not None
}
for option, value in defined_options.items():
old_value = old_dict.get(option)
if not value and not old_value:
@ -1859,12 +1859,12 @@ class DockerService(DockerBaseClass):
if not publish_item.get("mode"):
ignored_keys.add("mode")
# Create copies of publish_item dicts where keys specified in ignored_keys are left out
filtered_old_publish_item = dict(
(k, v) for k, v in old_publish_item.items() if k not in ignored_keys
)
filtered_publish_item = dict(
(k, v) for k, v in publish_item.items() if k not in ignored_keys
)
filtered_old_publish_item = {
k: v for k, v in old_publish_item.items() if k not in ignored_keys
}
filtered_publish_item = {
k: v for k, v in publish_item.items() if k not in ignored_keys
}
if filtered_publish_item != filtered_old_publish_item:
return True
return False
@ -2217,11 +2217,11 @@ class DockerServiceManager:
"StartPeriod": "start_period",
"Retries": "retries",
}
healthcheck = dict(
(options[key], value)
healthcheck = {
options[key]: value
for key, value in healthcheck_data.items()
if value is not None and key in options
)
}
ds.healthcheck = healthcheck
update_config_data = raw_data["Spec"].get("UpdateConfig")
@ -2262,7 +2262,7 @@ class DockerServiceManager:
)
for host in hosts
]
ds.hosts = dict((hostname, ip) for ip, hostname in hosts)
ds.hosts = {hostname: ip for ip, hostname in hosts}
ds.tty = task_template_data["ContainerSpec"].get("TTY")
placement = task_template_data.get("Placement")
@ -2272,10 +2272,10 @@ class DockerServiceManager:
placement_preferences = []
for preference in placement.get("Preferences", []):
placement_preferences.append(
dict(
(key.lower(), value["SpreadDescriptor"])
{
key.lower(): value["SpreadDescriptor"]
for key, value in preference.items()
)
}
)
ds.placement_preferences = placement_preferences or None
@ -2349,10 +2349,9 @@ class DockerServiceManager:
volume_options = mount_data.get("VolumeOptions", {})
tmpfs_options = mount_data.get("TmpfsOptions", {})
driver_config = volume_options.get("DriverConfig", {})
driver_config = (
dict((key.lower(), value) for key, value in driver_config.items())
or None
)
driver_config = {
key.lower(): value for key, value in driver_config.items()
} or None
ds.mounts.append(
{
"source": mount_data.get("Source", ""),
@ -2448,9 +2447,7 @@ class DockerServiceManager:
return f"{name}@{digest}"
def get_networks_names_ids(self):
return dict(
(network["Name"], network["Id"]) for network in self.client.networks()
)
return {network["Name"]: network["Id"] for network in self.client.networks()}
def get_missing_secret_ids(self):
"""
@ -2464,11 +2461,11 @@ class DockerServiceManager:
if not secret_names:
return {}
secrets = self.client.secrets(filters={"name": secret_names})
secrets = dict(
(secret["Spec"]["Name"], secret["ID"])
secrets = {
secret["Spec"]["Name"]: secret["ID"]
for secret in secrets
if secret["Spec"]["Name"] in secret_names
)
}
for secret_name in secret_names:
if secret_name not in secrets:
self.client.fail(f'Could not find a secret named "{secret_name}"')
@ -2486,11 +2483,11 @@ class DockerServiceManager:
if not config_names:
return {}
configs = self.client.configs(filters={"name": config_names})
configs = dict(
(config["Spec"]["Name"], config["ID"])
configs = {
config["Spec"]["Name"]: config["ID"]
for config in configs
if config["Spec"]["Name"] in config_names
)
}
for config_name in config_names:
if config_name not in configs:
self.client.fail(f'Could not find a config named "{config_name}"')
@ -2631,26 +2628,30 @@ def _detect_update_config_failure_action_rollback(client):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
image=dict(type="str"),
state=dict(type="str", default="present", choices=["present", "absent"]),
mounts=dict(
type="list",
elements="dict",
options=dict(
source=dict(type="str"),
target=dict(type="str", required=True),
type=dict(
type="str",
default="bind",
choices=["bind", "volume", "tmpfs", "npipe"],
),
readonly=dict(type="bool"),
labels=dict(type="dict"),
propagation=dict(
type="str",
choices=[
argument_spec = {
"name": {"type": "str", "required": True},
"image": {"type": "str"},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "absent"],
},
"mounts": {
"type": "list",
"elements": "dict",
"options": {
"source": {"type": "str"},
"target": {"type": "str", "required": True},
"type": {
"type": "str",
"default": "bind",
"choices": ["bind", "volume", "tmpfs", "npipe"],
},
"readonly": {"type": "bool"},
"labels": {"type": "dict"},
"propagation": {
"type": "str",
"choices": [
"shared",
"slave",
"private",
@ -2658,266 +2659,273 @@ def main():
"rslave",
"rprivate",
],
),
no_copy=dict(type="bool"),
driver_config=dict(
type="dict",
options=dict(name=dict(type="str"), options=dict(type="dict")),
),
tmpfs_size=dict(type="str"),
tmpfs_mode=dict(type="int"),
),
),
configs=dict(
type="list",
elements="dict",
options=dict(
config_id=dict(type="str"),
config_name=dict(type="str", required=True),
filename=dict(type="str"),
uid=dict(type="str"),
gid=dict(type="str"),
mode=dict(type="int"),
),
),
secrets=dict(
type="list",
elements="dict",
no_log=False,
options=dict(
secret_id=dict(type="str", no_log=False),
secret_name=dict(type="str", required=True, no_log=False),
filename=dict(type="str"),
uid=dict(type="str"),
gid=dict(type="str"),
mode=dict(type="int"),
),
),
networks=dict(type="list", elements="raw"),
command=dict(type="raw"),
args=dict(type="list", elements="str"),
env=dict(type="raw"),
env_files=dict(type="list", elements="path"),
force_update=dict(type="bool", default=False),
groups=dict(type="list", elements="str"),
logging=dict(
type="dict",
options=dict(
driver=dict(type="str"),
options=dict(type="dict"),
),
),
publish=dict(
type="list",
elements="dict",
options=dict(
published_port=dict(type="int", required=False),
target_port=dict(type="int", required=True),
protocol=dict(type="str", default="tcp", choices=["tcp", "udp"]),
mode=dict(type="str", choices=["ingress", "host"]),
),
),
placement=dict(
type="dict",
options=dict(
constraints=dict(type="list", elements="str"),
preferences=dict(type="list", elements="dict"),
replicas_max_per_node=dict(type="int"),
),
),
tty=dict(type="bool"),
dns=dict(type="list", elements="str"),
dns_search=dict(type="list", elements="str"),
dns_options=dict(type="list", elements="str"),
healthcheck=dict(
type="dict",
options=dict(
test=dict(type="raw"),
interval=dict(type="str"),
timeout=dict(type="str"),
start_period=dict(type="str"),
retries=dict(type="int"),
),
),
hostname=dict(type="str"),
hosts=dict(type="dict"),
labels=dict(type="dict"),
container_labels=dict(type="dict"),
sysctls=dict(type="dict"),
mode=dict(
type="str",
default="replicated",
choices=["replicated", "global", "replicated-job"],
),
replicas=dict(type="int", default=-1),
endpoint_mode=dict(type="str", choices=["vip", "dnsrr"]),
stop_grace_period=dict(type="str"),
stop_signal=dict(type="str"),
limits=dict(
type="dict",
options=dict(
cpus=dict(type="float"),
memory=dict(type="str"),
),
),
read_only=dict(type="bool"),
reservations=dict(
type="dict",
options=dict(
cpus=dict(type="float"),
memory=dict(type="str"),
),
),
resolve_image=dict(type="bool", default=False),
restart_config=dict(
type="dict",
options=dict(
condition=dict(type="str", choices=["none", "on-failure", "any"]),
delay=dict(type="str"),
max_attempts=dict(type="int"),
window=dict(type="str"),
),
),
rollback_config=dict(
type="dict",
options=dict(
parallelism=dict(type="int"),
delay=dict(type="str"),
failure_action=dict(type="str", choices=["continue", "pause"]),
monitor=dict(type="str"),
max_failure_ratio=dict(type="float"),
order=dict(type="str"),
),
),
update_config=dict(
type="dict",
options=dict(
parallelism=dict(type="int"),
delay=dict(type="str"),
failure_action=dict(
type="str", choices=["continue", "pause", "rollback"]
),
monitor=dict(type="str"),
max_failure_ratio=dict(type="float"),
order=dict(type="str"),
),
),
user=dict(type="str"),
working_dir=dict(type="str"),
init=dict(type="bool"),
cap_add=dict(type="list", elements="str"),
cap_drop=dict(type="list", elements="str"),
)
},
"no_copy": {"type": "bool"},
"driver_config": {
"type": "dict",
"options": {"name": {"type": "str"}, "options": {"type": "dict"}},
},
"tmpfs_size": {"type": "str"},
"tmpfs_mode": {"type": "int"},
},
},
"configs": {
"type": "list",
"elements": "dict",
"options": {
"config_id": {"type": "str"},
"config_name": {"type": "str", "required": True},
"filename": {"type": "str"},
"uid": {"type": "str"},
"gid": {"type": "str"},
"mode": {"type": "int"},
},
},
"secrets": {
"type": "list",
"elements": "dict",
"no_log": False,
"options": {
"secret_id": {"type": "str", "no_log": False},
"secret_name": {"type": "str", "required": True, "no_log": False},
"filename": {"type": "str"},
"uid": {"type": "str"},
"gid": {"type": "str"},
"mode": {"type": "int"},
},
},
"networks": {"type": "list", "elements": "raw"},
"command": {"type": "raw"},
"args": {"type": "list", "elements": "str"},
"env": {"type": "raw"},
"env_files": {"type": "list", "elements": "path"},
"force_update": {"type": "bool", "default": False},
"groups": {"type": "list", "elements": "str"},
"logging": {
"type": "dict",
"options": {
"driver": {"type": "str"},
"options": {"type": "dict"},
},
},
"publish": {
"type": "list",
"elements": "dict",
"options": {
"published_port": {"type": "int", "required": False},
"target_port": {"type": "int", "required": True},
"protocol": {
"type": "str",
"default": "tcp",
"choices": ["tcp", "udp"],
},
"mode": {"type": "str", "choices": ["ingress", "host"]},
},
},
"placement": {
"type": "dict",
"options": {
"constraints": {"type": "list", "elements": "str"},
"preferences": {"type": "list", "elements": "dict"},
"replicas_max_per_node": {"type": "int"},
},
},
"tty": {"type": "bool"},
"dns": {"type": "list", "elements": "str"},
"dns_search": {"type": "list", "elements": "str"},
"dns_options": {"type": "list", "elements": "str"},
"healthcheck": {
"type": "dict",
"options": {
"test": {"type": "raw"},
"interval": {"type": "str"},
"timeout": {"type": "str"},
"start_period": {"type": "str"},
"retries": {"type": "int"},
},
},
"hostname": {"type": "str"},
"hosts": {"type": "dict"},
"labels": {"type": "dict"},
"container_labels": {"type": "dict"},
"sysctls": {"type": "dict"},
"mode": {
"type": "str",
"default": "replicated",
"choices": ["replicated", "global", "replicated-job"],
},
"replicas": {"type": "int", "default": -1},
"endpoint_mode": {"type": "str", "choices": ["vip", "dnsrr"]},
"stop_grace_period": {"type": "str"},
"stop_signal": {"type": "str"},
"limits": {
"type": "dict",
"options": {
"cpus": {"type": "float"},
"memory": {"type": "str"},
},
},
"read_only": {"type": "bool"},
"reservations": {
"type": "dict",
"options": {
"cpus": {"type": "float"},
"memory": {"type": "str"},
},
},
"resolve_image": {"type": "bool", "default": False},
"restart_config": {
"type": "dict",
"options": {
"condition": {"type": "str", "choices": ["none", "on-failure", "any"]},
"delay": {"type": "str"},
"max_attempts": {"type": "int"},
"window": {"type": "str"},
},
},
"rollback_config": {
"type": "dict",
"options": {
"parallelism": {"type": "int"},
"delay": {"type": "str"},
"failure_action": {"type": "str", "choices": ["continue", "pause"]},
"monitor": {"type": "str"},
"max_failure_ratio": {"type": "float"},
"order": {"type": "str"},
},
},
"update_config": {
"type": "dict",
"options": {
"parallelism": {"type": "int"},
"delay": {"type": "str"},
"failure_action": {
"type": "str",
"choices": ["continue", "pause", "rollback"],
},
"monitor": {"type": "str"},
"max_failure_ratio": {"type": "float"},
"order": {"type": "str"},
},
},
"user": {"type": "str"},
"working_dir": {"type": "str"},
"init": {"type": "bool"},
"cap_add": {"type": "list", "elements": "str"},
"cap_drop": {"type": "list", "elements": "str"},
}
option_minimal_versions = dict(
dns=dict(docker_py_version="2.6.0"),
dns_options=dict(docker_py_version="2.6.0"),
dns_search=dict(docker_py_version="2.6.0"),
endpoint_mode=dict(docker_py_version="3.0.0"),
force_update=dict(docker_py_version="2.1.0"),
healthcheck=dict(docker_py_version="2.6.0"),
hostname=dict(docker_py_version="2.2.0"),
hosts=dict(docker_py_version="2.6.0"),
groups=dict(docker_py_version="2.6.0"),
tty=dict(docker_py_version="2.4.0"),
secrets=dict(docker_py_version="2.4.0"),
configs=dict(docker_py_version="2.6.0", docker_api_version="1.30"),
stop_signal=dict(docker_py_version="2.6.0", docker_api_version="1.28"),
publish=dict(docker_py_version="3.0.0"),
read_only=dict(docker_py_version="2.6.0", docker_api_version="1.28"),
resolve_image=dict(docker_api_version="1.30", docker_py_version="3.2.0"),
rollback_config=dict(docker_py_version="3.5.0", docker_api_version="1.28"),
init=dict(docker_py_version="4.0.0", docker_api_version="1.37"),
cap_add=dict(docker_py_version="5.0.3", docker_api_version="1.41"),
cap_drop=dict(docker_py_version="5.0.3", docker_api_version="1.41"),
sysctls=dict(docker_py_version="6.0.0", docker_api_version="1.40"),
option_minimal_versions = {
"dns": {"docker_py_version": "2.6.0"},
"dns_options": {"docker_py_version": "2.6.0"},
"dns_search": {"docker_py_version": "2.6.0"},
"endpoint_mode": {"docker_py_version": "3.0.0"},
"force_update": {"docker_py_version": "2.1.0"},
"healthcheck": {"docker_py_version": "2.6.0"},
"hostname": {"docker_py_version": "2.2.0"},
"hosts": {"docker_py_version": "2.6.0"},
"groups": {"docker_py_version": "2.6.0"},
"tty": {"docker_py_version": "2.4.0"},
"secrets": {"docker_py_version": "2.4.0"},
"configs": {"docker_py_version": "2.6.0", "docker_api_version": "1.30"},
"stop_signal": {"docker_py_version": "2.6.0", "docker_api_version": "1.28"},
"publish": {"docker_py_version": "3.0.0"},
"read_only": {"docker_py_version": "2.6.0", "docker_api_version": "1.28"},
"resolve_image": {"docker_api_version": "1.30", "docker_py_version": "3.2.0"},
"rollback_config": {"docker_py_version": "3.5.0", "docker_api_version": "1.28"},
"init": {"docker_py_version": "4.0.0", "docker_api_version": "1.37"},
"cap_add": {"docker_py_version": "5.0.3", "docker_api_version": "1.41"},
"cap_drop": {"docker_py_version": "5.0.3", "docker_api_version": "1.41"},
"sysctls": {"docker_py_version": "6.0.0", "docker_api_version": "1.40"},
# specials
publish_mode=dict(
docker_py_version="3.0.0",
detect_usage=_detect_publish_mode_usage,
usage_msg="set publish.mode",
),
healthcheck_start_period=dict(
docker_py_version="2.6.0",
docker_api_version="1.29",
detect_usage=_detect_healthcheck_start_period,
usage_msg="set healthcheck.start_period",
),
update_config_max_failure_ratio=dict(
docker_py_version="2.1.0",
detect_usage=lambda c: (c.module.params["update_config"] or {}).get(
"publish_mode": {
"docker_py_version": "3.0.0",
"detect_usage": _detect_publish_mode_usage,
"usage_msg": "set publish.mode",
},
"healthcheck_start_period": {
"docker_py_version": "2.6.0",
"docker_api_version": "1.29",
"detect_usage": _detect_healthcheck_start_period,
"usage_msg": "set healthcheck.start_period",
},
"update_config_max_failure_ratio": {
"docker_py_version": "2.1.0",
"detect_usage": lambda c: (c.module.params["update_config"] or {}).get(
"max_failure_ratio"
)
is not None,
usage_msg="set update_config.max_failure_ratio",
),
update_config_failure_action=dict(
docker_py_version="3.5.0",
docker_api_version="1.28",
detect_usage=_detect_update_config_failure_action_rollback,
usage_msg="set update_config.failure_action.rollback",
),
update_config_monitor=dict(
docker_py_version="2.1.0",
detect_usage=lambda c: (c.module.params["update_config"] or {}).get(
"usage_msg": "set update_config.max_failure_ratio",
},
"update_config_failure_action": {
"docker_py_version": "3.5.0",
"docker_api_version": "1.28",
"detect_usage": _detect_update_config_failure_action_rollback,
"usage_msg": "set update_config.failure_action.rollback",
},
"update_config_monitor": {
"docker_py_version": "2.1.0",
"detect_usage": lambda c: (c.module.params["update_config"] or {}).get(
"monitor"
)
is not None,
usage_msg="set update_config.monitor",
),
update_config_order=dict(
docker_py_version="2.7.0",
docker_api_version="1.29",
detect_usage=lambda c: (c.module.params["update_config"] or {}).get("order")
is not None,
usage_msg="set update_config.order",
),
placement_config_preferences=dict(
docker_py_version="2.4.0",
docker_api_version="1.27",
detect_usage=lambda c: (c.module.params["placement"] or {}).get(
"preferences"
)
is not None,
usage_msg="set placement.preferences",
),
placement_config_constraints=dict(
docker_py_version="2.4.0",
detect_usage=lambda c: (c.module.params["placement"] or {}).get(
"constraints"
)
is not None,
usage_msg="set placement.constraints",
),
placement_config_replicas_max_per_node=dict(
docker_py_version="4.4.3",
docker_api_version="1.40",
detect_usage=lambda c: (c.module.params["placement"] or {}).get(
"replicas_max_per_node"
)
is not None,
usage_msg="set placement.replicas_max_per_node",
),
mounts_tmpfs=dict(
docker_py_version="2.6.0",
detect_usage=_detect_mount_tmpfs_usage,
usage_msg="set mounts.tmpfs",
),
rollback_config_order=dict(
docker_api_version="1.29",
detect_usage=lambda c: (c.module.params["rollback_config"] or {}).get(
"usage_msg": "set update_config.monitor",
},
"update_config_order": {
"docker_py_version": "2.7.0",
"docker_api_version": "1.29",
"detect_usage": lambda c: (c.module.params["update_config"] or {}).get(
"order"
)
is not None,
usage_msg="set rollback_config.order",
),
mode_replicated_job=dict(
docker_py_version="6.0.0",
docker_api_version="1.41",
detect_usage=lambda c: c.module.params.get("mode") == "replicated-job",
usage_msg="set mode",
),
)
"usage_msg": "set update_config.order",
},
"placement_config_preferences": {
"docker_py_version": "2.4.0",
"docker_api_version": "1.27",
"detect_usage": lambda c: (c.module.params["placement"] or {}).get(
"preferences"
)
is not None,
"usage_msg": "set placement.preferences",
},
"placement_config_constraints": {
"docker_py_version": "2.4.0",
"detect_usage": lambda c: (c.module.params["placement"] or {}).get(
"constraints"
)
is not None,
"usage_msg": "set placement.constraints",
},
"placement_config_replicas_max_per_node": {
"docker_py_version": "4.4.3",
"docker_api_version": "1.40",
"detect_usage": lambda c: (c.module.params["placement"] or {}).get(
"replicas_max_per_node"
)
is not None,
"usage_msg": "set placement.replicas_max_per_node",
},
"mounts_tmpfs": {
"docker_py_version": "2.6.0",
"detect_usage": _detect_mount_tmpfs_usage,
"usage_msg": "set mounts.tmpfs",
},
"rollback_config_order": {
"docker_api_version": "1.29",
"detect_usage": lambda c: (c.module.params["rollback_config"] or {}).get(
"order"
)
is not None,
"usage_msg": "set rollback_config.order",
},
"mode_replicated_job": {
"docker_py_version": "6.0.0",
"docker_api_version": "1.41",
"detect_usage": lambda c: c.module.params.get("mode") == "replicated-job",
"usage_msg": "set mode",
},
}
required_if = [("state", "present", ["image"])]
client = AnsibleDockerClient(
@ -2932,16 +2940,16 @@ def main():
dsm = DockerServiceManager(client)
msg, changed, rebuilt, changes, facts = dsm.run_safe()
results = dict(
msg=msg,
changed=changed,
rebuilt=rebuilt,
changes=changes,
swarm_service=facts,
)
results = {
"msg": msg,
"changed": changed,
"rebuilt": rebuilt,
"changes": changes,
"swarm_service": facts,
}
if client.module._diff:
before, after = dsm.diff_tracker.get_before_after()
results["diff"] = dict(before=before, after=after)
results["diff"] = {"before": before, "after": after}
client.module.exit_json(**results)
except DockerException as e:

6
plugins/modules/docker_swarm_service_info.py
View File

@ -85,9 +85,9 @@ def get_service_info(client):
def main():
argument_spec = dict(
name=dict(type="str", required=True),
)
argument_spec = {
"name": {"type": "str", "required": True},
}
client = AnsibleDockerSwarmClient(
argument_spec=argument_spec,

30
plugins/modules/docker_volume.py
View File

@ -161,7 +161,7 @@ class DockerVolumeManager:
self.results = {"changed": False, "actions": []}
self.diff = self.client.module._diff
self.diff_tracker = DifferenceTracker()
self.diff_result = dict()
self.diff_result = {}
self.existing_volume = self.get_existing_volume()
@ -309,17 +309,23 @@ class DockerVolumeManager:
def main():
argument_spec = dict(
volume_name=dict(type="str", required=True, aliases=["name"]),
state=dict(type="str", default="present", choices=["present", "absent"]),
driver=dict(type="str", default="local"),
driver_options=dict(type="dict", default={}),
labels=dict(type="dict"),
recreate=dict(
type="str", default="never", choices=["always", "never", "options-changed"]
),
debug=dict(type="bool", default=False),
)
argument_spec = {
"volume_name": {"type": "str", "required": True, "aliases": ["name"]},
"state": {
"type": "str",
"default": "present",
"choices": ["present", "absent"],
},
"driver": {"type": "str", "default": "local"},
"driver_options": {"type": "dict", "default": {}},
"labels": {"type": "dict"},
"recreate": {
"type": "str",
"default": "never",
"choices": ["always", "never", "options-changed"],
},
"debug": {"type": "bool", "default": False},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,

6
plugins/modules/docker_volume_info.py
View File

@ -92,9 +92,9 @@ def get_existing_volume(client, volume_name):
def main():
argument_spec = dict(
name=dict(type="str", required=True, aliases=["volume_name"]),
)
argument_spec = {
"name": {"type": "str", "required": True, "aliases": ["volume_name"]},
}
client = AnsibleDockerClient(
argument_spec=argument_spec,