Debian Codegraph @

ansible_collections/containers/podman/plugins/modules/podman_network.py

raw
1 #!/usr/bin/python
2 # Copyright (c) 2020 Red Hat
3 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
4
5 from __future__ import absolute_import, division, print_function
6
7 __metaclass__ = type
8
9
10 DOCUMENTATION = r"""
11 module: podman_network
12 author:
13 - "Sagi Shnaidman (@sshnaidm)"
14 version_added: '1.0.0'
15 short_description: Manage podman networks
16 notes: []
17 description:
18 - Manage podman networks with podman network command.
19 requirements:
20 - podman
21 - ipaddress (for ip_range idempotency checks)
22 options:
23 name:
24 description:
25 - Name of the network
26 type: str
27 required: True
28 executable:
29 description:
30 - Path to C(podman) executable if it is not in the C($PATH) on the
31 machine running C(podman)
32 default: 'podman'
33 type: str
34 disable_dns:
35 description:
36 - disable dns plugin (default "false")
37 type: bool
38 dns:
39 description:
40 - Set network-scoped DNS resolver/nameserver for containers in this network.
41 If not set, the host servers from /etc/resolv.conf is used.
42 type: list
43 elements: str
44 driver:
45 description:
46 - Driver to manage the network (default "bridge")
47 type: str
48 force:
49 description:
50 - Remove all containers that use the network.
51 If the container is running, it is stopped and removed.
52 default: False
53 type: bool
54 gateway:
55 description:
56 - IPv4 or IPv6 gateway for the subnet
57 type: str
58 interface_name:
59 description:
60 - For bridge, it uses the bridge interface name.
61 For macvlan, it is the parent device on the host (it is the same
62 as 'opt.parent')
63 type: str
64 internal:
65 description:
66 - Restrict external access from this network (default "false")
67 type: bool
68 ip_range:
69 description:
70 - Allocate container IP from range
71 type: str
72 ipam_driver:
73 description:
74 - Set the ipam driver (IP Address Management Driver) for the network.
75 When unset podman chooses an ipam driver automatically based on the network driver
76 type: str
77 choices:
78 - host-local
79 - dhcp
80 - none
81 ipv6:
82 description:
83 - Enable IPv6 (Dual Stack) networking. You must pass a IPv6 subnet.
84 The subnet option must be used with the ipv6 option.
85 Idempotency is not supported because it generates subnets randomly.
86 type: bool
87 route:
88 description:
89 - A static route in the format <destination in CIDR notation>,<gateway>,<route metric (optional)>.
90 This route will be added to every container in this network.
91 type: list
92 elements: str
93 subnet:
94 description:
95 - Subnet in CIDR format
96 type: str
97 macvlan:
98 description:
99 - Create a Macvlan connection based on this device
100 type: str
101 net_config:
102 description:
103 - List of dictionaries with network configuration.
104 Each dictionary should contain 'subnet' and 'gateway' keys.
105 'ip_range' is optional.
106 type: list
107 elements: dict
108 suboptions:
109 subnet:
110 description:
111 - Subnet in CIDR format
112 type: str
113 required: true
114 gateway:
115 description:
116 - Gateway for the subnet
117 type: str
118 required: true
119 ip_range:
120 description:
121 - Allocate container IP from range
122 type: str
123 required: false
124 opt:
125 description:
126 - Add network options. Currently 'vlan' and 'mtu' are supported.
127 type: dict
128 suboptions:
129 bclim:
130 description:
131 - Set the threshold for broadcast queueing. Must be a 32 bit integer.
132 Setting this value to -1 disables broadcast queueing altogether.
133 type: int
134 required: false
135 bridge_name:
136 description:
137 - This option assigns the given name to the created Linux Bridge.
138 Sets 'com.docker.network.bridge.name' option.
139 type: str
140 required: false
141 driver_mtu:
142 description:
143 - Sets the Maximum Transmission Unit (MTU) and takes an integer value.
144 Sets 'com.docker.network.driver.mtu' option.
145 type: str
146 required: false
147 isolate:
148 description:
149 - This option isolates networks by blocking traffic between those
150 that have this option enabled.
151 type: bool
152 required: false
153 metric:
154 description:
155 - Sets the Route Metric for the default route created in every
156 container joined to this network.
157 Can only be used with the Netavark network backend.
158 type: int
159 required: false
160 mode:
161 description:
162 - This option sets the specified ip/macvlan mode on the interface.
163 type: str
164 required: false
165 mtu:
166 description:
167 - MTU size for bridge network interface.
168 type: int
169 required: false
170 no_default_route:
171 description:
172 - If set to 1, Podman will NOT automatically add a default route to subnets.
173 type: str
174 required: false
175 parent:
176 description:
177 - The host device which should be used for the macvlan interface
178 (it is the same as 'interface' in that case).
179 Defaults to the default route interface.
180 type: str
181 required: false
182 vlan:
183 description:
184 - VLAN tag for bridge which enables vlan_filtering.
185 type: int
186 required: false
187 vrf:
188 description:
189 - This option assigns a VRF to the bridge interface.
190 It accepts the name of the VRF and defaults to none.
191 Can only be used with the Netavark network backend.
192 type: str
193 required: false
194 debug:
195 description:
196 - Return additional information which can be helpful for investigations.
197 type: bool
198 default: False
199 state:
200 description:
201 - State of network, default 'present'
202 type: str
203 default: present
204 choices:
205 - present
206 - absent
207 - quadlet
208 recreate:
209 description:
210 - Recreate network even if exists.
211 type: bool
212 default: false
213 quadlet_dir:
214 description:
215 - Path to the directory to write quadlet file in.
216 By default, it will be set as C(/etc/containers/systemd/) for root user,
217 C(~/.config/containers/systemd/) for non-root users.
218 type: path
219 required: false
220 quadlet_filename:
221 description:
222 - Name of quadlet file to write. By default it takes I(name) value.
223 type: str
224 quadlet_file_mode:
225 description:
226 - The permissions of the quadlet file.
227 - The O(quadlet_file_mode) can be specified as octal numbers or as a symbolic mode (for example, V(u+rwx) or V(u=rw,g=r,o=r)).
228 For octal numbers format, you must either add a leading zero so that Ansible's YAML parser knows it is an
229 octal number (like V(0644) or V(01777)) or quote it (like V('644') or V('1777')) so Ansible receives a string
230 and can do its own conversion from string into number. Giving Ansible a number without following one of these
231 rules will end up with a decimal number which will have unexpected results.
232 - If O(quadlet_file_mode) is not specified and the quadlet file B(does not) exist, the default V('0640') mask will be used
233 when setting the mode for the newly created file.
234 - If O(quadlet_file_mode) is not specified and the quadlet file B(does) exist, the mode of the existing file will be used.
235 - Specifying O(quadlet_file_mode) is the best way to ensure files are created with the correct permissions.
236 type: raw
237 required: false
238 quadlet_options:
239 description:
240 - Options for the quadlet file. Provide missing in usual network args
241 options as a list of lines to add.
242 type: list
243 elements: str
244 required: false
245 """
246
247 EXAMPLES = r"""
248 - name: Create a podman network
249 containers.podman.podman_network:
250 name: podman_network
251 become: true
252
253 - name: Create internal podman network
254 containers.podman.podman_network:
255 name: podman_internal
256 internal: true
257 ip_range: 192.168.22.128/25
258 subnet: 192.168.22.0/24
259 gateway: 192.168.22.1
260 become: true
261
262 - name: Create Quadlet file for podman network
263 containers.podman.podman_network:
264 name: podman_network
265 state: quadlet
266 quadlet_options:
267 - IPv6=true
268 - Label="ipv6 network"
269 """
270
271 RETURN = r"""
272 network:
273 description: Facts from created or updated networks
274 returned: always
275 type: list
276 sample: [
277 {
278 "name": "virtuals",
279 "id": "3f46dc2626fe082b1ec703bc74d048765c1110c9eab7d61e33344e212279402c",
280 "driver": "bridge",
281 "network_interface": "podman2",
282 "created": "2024-07-13T15:43:36.548472483+03:00",
283 "subnets": [
284 {
285 "subnet": "10.99.99.0/24",
286 "gateway": "10.99.99.1"
287 }
288 ],
289 "ipv6_enabled": false,
290 "internal": false,
291 "dns_enabled": true,
292 "ipam_options": {
293 "driver": "host-local"
294 }
295 }
296 ]
297 """
298
299 import json
300
301 try:
302 import ipaddress
303
304 HAS_IP_ADDRESS_MODULE = True
305 except ImportError:
306 HAS_IP_ADDRESS_MODULE = False
307
308 from ansible.module_utils.basic import AnsibleModule # noqa: F402
309
310 try:
311 from ansible.module_utils.common.text.converters import to_native, to_bytes # noqa: F402
312 except ImportError:
313 from ansible.module_utils.common.text import to_native, to_bytes # noqa: F402
314 from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
315 LooseVersion,
316 )
317 from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
318 lower_keys,
319 )
320 from ansible_collections.containers.podman.plugins.module_utils.podman.quadlet import (
321 create_quadlet_state,
322 )
323
324
325 class PodmanNetworkModuleParams:
326 """Creates list of arguments for podman CLI command.
327
328 Arguments:
329 action {str} -- action type from 'create', 'delete'
330 params {dict} -- dictionary of module parameters
331
332 """
333
334 def __init__(self, action, params, podman_version, module):
335 self.params = params
336 self.action = action
337 self.podman_version = podman_version
338 self.module = module
339
340 def construct_command_from_params(self):
341 """Create a podman command from given module parameters.
342
343 Returns:
344 list -- list of byte strings for Popen command
345 """
346 if self.action in ["delete"]:
347 return self._delete_action()
348 if self.action in ["create"]:
349 return self._create_action()
350
351 def _delete_action(self):
352 cmd = ["rm", self.params["name"]]
353 if self.params["force"]:
354 cmd += ["--force"]
355 return [to_bytes(i, errors="surrogate_or_strict") for i in cmd]
356
357 def _create_action(self):
358 cmd = [self.action, self.params["name"]]
359 all_param_methods = [
360 func for func in dir(self) if callable(getattr(self, func)) and func.startswith("addparam")
361 ]
362 params_set = (i for i in self.params if self.params[i] is not None)
363 for param in params_set:
364 func_name = "_".join(["addparam", param])
365 if func_name in all_param_methods:
366 cmd = getattr(self, func_name)(cmd)
367 return [to_bytes(i, errors="surrogate_or_strict") for i in cmd]
368
369 def check_version(self, param, minv=None, maxv=None):
370 if minv and LooseVersion(minv) > LooseVersion(self.podman_version):
371 self.module.fail_json(
372 msg="Parameter %s is supported from podman "
373 "version %s only! Current version is %s" % (param, minv, self.podman_version)
374 )
375 if maxv and LooseVersion(maxv) < LooseVersion(self.podman_version):
376 self.module.fail_json(
377 msg="Parameter %s is supported till podman "
378 "version %s only! Current version is %s" % (param, minv, self.podman_version)
379 )
380
381 def addparam_gateway(self, c):
382 return c + ["--gateway", self.params["gateway"]]
383
384 def addparam_dns(self, c):
385 for dns in self.params["dns"]:
386 c += ["--dns", dns]
387 return c
388
389 def addparam_driver(self, c):
390 return c + ["--driver", self.params["driver"]]
391
392 def addparam_subnet(self, c):
393 return c + ["--subnet", self.params["subnet"]]
394
395 def addparam_ip_range(self, c):
396 return c + ["--ip-range", self.params["ip_range"]]
397
398 def addparam_ipv6(self, c):
399 return c + ["--ipv6=%s" % self.params["ipv6"]]
400
401 def addparam_macvlan(self, c):
402 return c + ["--macvlan", self.params["macvlan"]]
403
404 def addparam_net_config(self, c):
405 for net in self.params["net_config"]:
406 for kw in ("subnet", "gateway", "ip_range"):
407 if kw in net and net[kw]:
408 c += ["--%s=%s" % (kw.replace("_", "-"), net[kw])]
409 return c
410
411 def addparam_interface_name(self, c):
412 return c + ["--interface-name", self.params["interface_name"]]
413
414 def addparam_internal(self, c):
415 return c + ["--internal=%s" % self.params["internal"]]
416
417 def addparam_opt(self, c):
418 for opt in self.params["opt"].items():
419 if opt[1] is not None:
420 if opt[0] == "bridge_name":
421 opt = ("com.docker.network.bridge.name", opt[1])
422 if opt[0] == "driver_mtu":
423 opt = ("com.docker.network.driver.mtu", opt[1])
424 c += [
425 "--opt",
426 b"=".join([to_bytes(k, errors="surrogate_or_strict") for k in opt]),
427 ]
428 return c
429
430 def addparam_route(self, c):
431 for route in self.params["route"]:
432 c += ["--route", route]
433 return c
434
435 def addparam_ipam_driver(self, c):
436 return c + ["--ipam-driver=%s" % self.params["ipam_driver"]]
437
438 def addparam_disable_dns(self, c):
439 return c + ["--disable-dns=%s" % self.params["disable_dns"]]
440
441
442 class PodmanNetworkDefaults:
443 def __init__(self, module, podman_version):
444 self.module = module
445 self.version = podman_version
446 self.defaults = {
447 "driver": "bridge",
448 "internal": False,
449 }
450
451 def default_dict(self):
452 # make here any changes to self.defaults related to podman version
453 return self.defaults
454
455
456 class PodmanNetworkDiff:
457 def __init__(self, module, info, podman_version):
458 self.module = module
459 self.version = podman_version
460 self.default_dict = None
461 self.info = lower_keys(info)
462 self.params = self.defaultize()
463 self.diff = {"before": {}, "after": {}}
464 self.non_idempotent = {}
465
466 def defaultize(self):
467 params_with_defaults = {}
468 self.default_dict = PodmanNetworkDefaults(self.module, self.version).default_dict()
469 for p in self.module.params:
470 if self.module.params[p] is None and p in self.default_dict:
471 params_with_defaults[p] = self.default_dict[p]
472 else:
473 params_with_defaults[p] = self.module.params[p]
474 return params_with_defaults
475
476 def _diff_update_and_compare(self, param_name, before, after):
477 if before != after:
478 self.diff["before"].update({param_name: before})
479 self.diff["after"].update({param_name: after})
480 return True
481 return False
482
483 @staticmethod
484 def _lease_range_to_str(lease_range):
485 """Convert lease_range dict to normalized start-end string."""
486 return f'{lease_range["start_ip"]}-{lease_range["end_ip"]}'
487
488 @staticmethod
489 def _ip_range_to_str(ip_range_cidr):
490 """Convert CIDR ip_range to normalized start-end string.
491
492 Podman excludes the network address from the lease range,
493 so start = network_address + 1, end = broadcast_address.
494 """
495 net = ipaddress.ip_network(ip_range_cidr, strict=False)
496 start = net.network_address + 1
497 end = net.broadcast_address
498 return f"{start}-{end}"
499
500 def diffparam_disable_dns(self):
501 # For v3 it's impossible to find out DNS settings.
502 if LooseVersion(self.version) >= LooseVersion("4.0.0"):
503 before = not self.info.get("dns_enabled", True)
504 after = self.params["disable_dns"]
505 # compare only if set explicitly
506 if self.params["disable_dns"] is None:
507 after = before
508 return self._diff_update_and_compare("disable_dns", before, after)
509 before = after = self.params["disable_dns"]
510 return self._diff_update_and_compare("disable_dns", before, after)
511
512 def diffparam_dns(self):
513 before = self.info.get("network_dns_servers", [])
514 after = self.params["dns"] or []
515 return self._diff_update_and_compare("dns", sorted(before), sorted(after))
516
517 def diffparam_driver(self):
518 # Currently only bridge is supported
519 before = after = "bridge"
520 return self._diff_update_and_compare("driver", before, after)
521
522 def diffparam_ipv6(self):
523 # We don't support dual stack because it generates subnets randomly
524 return self._diff_update_and_compare("ipv6", "", "")
525
526 def diffparam_gateway(self):
527 # Disable idempotency of subnet for v4, subnets are added automatically
528 # TODO(sshnaidm): check if it's still the issue in v5
529 if LooseVersion(self.version) < LooseVersion("4.0.0"):
530 try:
531 before = self.info["plugins"][0]["ipam"]["ranges"][0][0]["gateway"]
532 except (IndexError, KeyError):
533 before = ""
534 after = before
535 if self.params["gateway"] is not None:
536 after = self.params["gateway"]
537 return self._diff_update_and_compare("gateway", before, after)
538 else:
539 before_subs = self.info.get("subnets")
540 after = self.params["gateway"]
541 if not before_subs:
542 before = None
543 if before_subs:
544 if len(before_subs) > 1 and after:
545 return self._diff_update_and_compare(
546 "gateway", ",".join([i["gateway"] for i in before_subs]), after
547 )
548 before = [i.get("gateway") for i in before_subs][0]
549 if not after:
550 after = before
551 return self._diff_update_and_compare("gateway", before, after)
552
553 def diffparam_internal(self):
554 if LooseVersion(self.version) >= LooseVersion("4.0.0"):
555 before = self.info.get("internal", False)
556 after = self.params["internal"]
557 return self._diff_update_and_compare("internal", before, after)
558 try:
559 before = not self.info["plugins"][0]["isgateway"]
560 except (IndexError, KeyError):
561 before = False
562 after = self.params["internal"]
563 return self._diff_update_and_compare("internal", before, after)
564
565 def diffparam_ip_range(self):
566 if not HAS_IP_ADDRESS_MODULE:
567 self.module.warn(
568 "Python 'ipaddress' module is not available. "
569 "Skipping ip_range idempotency check.")
570 return False
571 before = ""
572 after = self.params["ip_range"] or ""
573 if after:
574 after = self._ip_range_to_str(after)
575 before_subs = self.info.get("subnets", [])
576 if before_subs:
577 lr = before_subs[0].get("lease_range")
578 if lr:
579 before = self._lease_range_to_str(lr)
580 return self._diff_update_and_compare("ip_range", before, after)
581
582 def diffparam_ipam_driver(self):
583 before = self.info.get("ipam_options", {}).get("driver", "")
584 after = self.params["ipam_driver"]
585 if not after:
586 after = before
587 return self._diff_update_and_compare("ipam_driver", before, after)
588
589 def diffparam_net_config(self):
590 after = self.params["net_config"]
591 if not after:
592 return self._diff_update_and_compare("net_config", "", "")
593 before_subs = self.info.get("subnets", [])
594 if before_subs:
595 before_parts = []
596 for i in before_subs:
597 parts = [i["subnet"], i.get("gateway") or ""]
598 lr = i.get("lease_range")
599 if lr:
600 parts.append(self._lease_range_to_str(lr))
601 before_parts.append(",".join(parts))
602 before = ":".join(sorted(before_parts))
603 else:
604 before = ""
605 after_parts = []
606 for i in after:
607 parts = [i["subnet"], i.get("gateway") or ""]
608 if i.get("ip_range"):
609 if HAS_IP_ADDRESS_MODULE:
610 parts.append(self._ip_range_to_str(i["ip_range"]))
611 else:
612 self.module.warn(
613 "Python 'ipaddress' module is not available. "
614 "Skipping ip_range idempotency check in net_config.")
615 after_parts.append(",".join(parts))
616 after = ":".join(sorted(after_parts))
617 return self._diff_update_and_compare("net_config", before, after)
618
619 def diffparam_route(self):
620 routes = self.info.get("routes", [])
621 if routes:
622 before = [",".join([r["destination"], r["gateway"], str(r.get("metric", ""))]).rstrip(",") for r in routes]
623 else:
624 before = []
625 after = self.params["route"] or []
626 return self._diff_update_and_compare("route", sorted(before), sorted(after))
627
628 def diffparam_subnet(self):
629 # Disable idempotency of subnet for v3 and below
630 if LooseVersion(self.version) < LooseVersion("4.0.0"):
631 try:
632 before = self.info["plugins"][0]["ipam"]["ranges"][0][0]["subnet"]
633 except (IndexError, KeyError):
634 before = ""
635 after = before
636 if self.params["subnet"] is not None:
637 after = self.params["subnet"]
638 if HAS_IP_ADDRESS_MODULE:
639 after = ipaddress.ip_network(after).compressed
640 return self._diff_update_and_compare("subnet", before, after)
641 else:
642 if self.params["ipv6"] is not None:
643 # We can't support dual stack, it generates subnets randomly
644 return self._diff_update_and_compare("subnet", "", "")
645 after = self.params["subnet"]
646 if after is None:
647 # We can't guess what subnet was used before by default
648 return self._diff_update_and_compare("subnet", "", "")
649 before = self.info.get("subnets")
650 if before:
651 if len(before) > 1 and after:
652 return self._diff_update_and_compare("subnet", ",".join([i["subnet"] for i in before]), after)
653 before = [i["subnet"] for i in before][0]
654 return self._diff_update_and_compare("subnet", before, after)
655
656 def diffparam_macvlan(self):
657 before = after = ""
658 return self._diff_update_and_compare("macvlan", before, after)
659
660 def diffparam_opt(self):
661 if LooseVersion(self.version) >= LooseVersion("4.0.0"):
662 vlan_before = self.info.get("options", {}).get("vlan")
663 else:
664 try:
665 vlan_before = self.info["plugins"][0].get("vlan")
666 except (IndexError, KeyError):
667 vlan_before = None
668 vlan_after = self.params["opt"].get("vlan") if self.params["opt"] else None
669 if vlan_before or vlan_after:
670 before, after = {"vlan": str(vlan_before)}, {"vlan": str(vlan_after)}
671 else:
672 before, after = {}, {}
673 if LooseVersion(self.version) >= LooseVersion("4.0.0"):
674 mtu_before = self.info.get("options", {}).get("mtu")
675 else:
676 try:
677 mtu_before = self.info["plugins"][0].get("mtu")
678 except (IndexError, KeyError):
679 mtu_before = None
680 mtu_after = self.params["opt"].get("mtu") if self.params["opt"] else None
681 if mtu_before or mtu_after:
682 before.update({"mtu": str(mtu_before)})
683 after.update({"mtu": str(mtu_after)})
684 return self._diff_update_and_compare("opt", before, after)
685
686 def is_different(self):
687 diff_func_list = [func for func in dir(self) if callable(getattr(self, func)) and func.startswith("diffparam")]
688 fail_fast = not bool(self.module._diff)
689 different = False
690 for func_name in diff_func_list:
691 dff_func = getattr(self, func_name)
692 if dff_func():
693 if fail_fast:
694 return True
695 different = True
696 # Check non idempotent parameters
697 for p in self.non_idempotent:
698 if self.module.params[p] is not None and self.module.params[p] not in [
699 {},
700 [],
701 "",
702 ]:
703 different = True
704 return different
705
706
707 class PodmanNetwork:
708 """Perform network tasks.
709
710 Manages podman network, inspects it and checks its current state
711 """
712
713 def __init__(self, module, name):
714 """Initialize PodmanNetwork class.
715
716 Arguments:
717 module {obj} -- ansible module object
718 name {str} -- name of network
719 """
720
721 super(PodmanNetwork, self).__init__()
722 self.module = module
723 self.name = name
724 self.stdout, self.stderr = "", ""
725 self.info = self.get_info()
726 self.version = self._get_podman_version()
727 self.diff = {}
728 self.actions = []
729
730 @property
731 def exists(self):
732 """Check if network exists."""
733 return bool(self.info != {})
734
735 @property
736 def different(self):
737 """Check if network is different."""
738 diffcheck = PodmanNetworkDiff(self.module, self.info, self.version)
739 is_different = diffcheck.is_different()
740 diffs = diffcheck.diff
741 if self.module._diff and is_different and diffs["before"] and diffs["after"]:
742 self.diff["before"] = "\n".join(["%s - %s" % (k, v) for k, v in sorted(diffs["before"].items())]) + "\n"
743 self.diff["after"] = "\n".join(["%s - %s" % (k, v) for k, v in sorted(diffs["after"].items())]) + "\n"
744 return is_different
745
746 def get_info(self):
747 """Inspect network and gather info about it."""
748 # pylint: disable=unused-variable
749 rc, out, err = self.module.run_command([self.module.params["executable"], b"network", b"inspect", self.name])
750 return json.loads(out)[0] if rc == 0 else {}
751
752 def _get_podman_version(self):
753 # pylint: disable=unused-variable
754 rc, out, err = self.module.run_command([self.module.params["executable"], b"--version"])
755 if rc != 0 or not out or "version" not in out:
756 self.module.fail_json(msg="%s run failed!" % self.module.params["executable"])
757 return out.split("version")[1].strip()
758
759 def _perform_action(self, action):
760 """Perform action with network.
761
762 Arguments:
763 action {str} -- action to perform - create, stop, delete
764 """
765 b_command = PodmanNetworkModuleParams(
766 action,
767 self.module.params,
768 self.version,
769 self.module,
770 ).construct_command_from_params()
771 full_cmd = " ".join([self.module.params["executable"], "network"] + [to_native(i) for i in b_command])
772 self.module.log("PODMAN-NETWORK-DEBUG: %s" % full_cmd)
773 self.actions.append(full_cmd)
774 if not self.module.check_mode:
775 rc, out, err = self.module.run_command(
776 [self.module.params["executable"], b"network"] + b_command,
777 expand_user_and_vars=False,
778 )
779 self.stdout = out
780 self.stderr = err
781 if rc != 0:
782 self.module.fail_json(
783 msg="Can't %s network %s" % (action, self.name),
784 stdout=out,
785 stderr=err,
786 )
787
788 def delete(self):
789 """Delete the network."""
790 self._perform_action("delete")
791
792 def create(self):
793 """Create the network."""
794 self._perform_action("create")
795
796 def recreate(self):
797 """Recreate the network."""
798 self.delete()
799 self.create()
800
801
802 class PodmanNetworkManager:
803 """Module manager class.
804
805 Defines according to parameters what actions should be applied to network
806 """
807
808 def __init__(self, module):
809 """Initialize PodmanManager class.
810
811 Arguments:
812 module {obj} -- ansible module object
813 """
814
815 super(PodmanNetworkManager, self).__init__()
816
817 self.module = module
818 self.results = {
819 "changed": False,
820 "actions": [],
821 "network": {},
822 }
823 self.name = self.module.params["name"]
824 self.executable = self.module.get_bin_path(self.module.params["executable"], required=True)
825 self.state = self.module.params["state"]
826 self.recreate = self.module.params["recreate"]
827 self.network = PodmanNetwork(self.module, self.name)
828
829 def update_network_result(self, changed=True):
830 """Inspect the current network, update results with last info, exit.
831
832 Keyword Arguments:
833 changed {bool} -- whether any action was performed
834 (default: {True})
835 """
836 facts = self.network.get_info() if changed else self.network.info
837 out, err = self.network.stdout, self.network.stderr
838 self.results.update(
839 {
840 "changed": changed,
841 "network": facts,
842 "podman_actions": self.network.actions,
843 },
844 stdout=out,
845 stderr=err,
846 )
847 if self.network.diff:
848 self.results.update({"diff": self.network.diff})
849 if self.module.params["debug"]:
850 self.results.update({"podman_version": self.network.version})
851 self.module.exit_json(**self.results)
852
853 def execute(self):
854 """Execute the desired action according to map of actions & states."""
855 states_map = {
856 "present": self.make_present,
857 "absent": self.make_absent,
858 "quadlet": self.make_quadlet,
859 }
860 process_action = states_map[self.state]
861 process_action()
862 self.module.fail_json(msg="Unexpected logic error happened, " "please contact maintainers ASAP!")
863
864 def make_present(self):
865 """Run actions if desired state is 'started'."""
866 if not self.network.exists:
867 self.network.create()
868 self.results["actions"].append("created %s" % self.network.name)
869 self.update_network_result()
870 elif self.recreate or self.network.different:
871 self.network.recreate()
872 self.results["actions"].append("recreated %s" % self.network.name)
873 self.update_network_result()
874 else:
875 self.update_network_result(changed=False)
876
877 def make_absent(self):
878 """Run actions if desired state is 'absent'."""
879 if not self.network.exists:
880 self.results.update({"changed": False})
881 elif self.network.exists:
882 self.network.delete()
883 self.results["actions"].append("deleted %s" % self.network.name)
884 self.results.update({"changed": True})
885 self.results.update({"network": {}, "podman_actions": self.network.actions})
886 self.module.exit_json(**self.results)
887
888 def make_quadlet(self):
889 results_update = create_quadlet_state(self.module, "network")
890 self.results.update(results_update)
891 self.module.exit_json(**self.results)
892
893
894 def main():
895 module = AnsibleModule(
896 argument_spec=dict(
897 state=dict(type="str", default="present", choices=["present", "absent", "quadlet"]),
898 name=dict(type="str", required=True),
899 disable_dns=dict(type="bool", required=False),
900 dns=dict(type="list", elements="str", required=False),
901 driver=dict(type="str", required=False),
902 force=dict(type="bool", default=False),
903 gateway=dict(type="str", required=False),
904 interface_name=dict(type="str", required=False),
905 internal=dict(type="bool", required=False),
906 ip_range=dict(type="str", required=False),
907 ipam_driver=dict(type="str", required=False, choices=["host-local", "dhcp", "none"]),
908 ipv6=dict(type="bool", required=False),
909 subnet=dict(type="str", required=False),
910 macvlan=dict(type="str", required=False),
911 opt=dict(
912 type="dict",
913 required=False,
914 options=dict(
915 isolate=dict(type="bool", required=False),
916 mtu=dict(type="int", required=False),
917 metric=dict(type="int", required=False),
918 mode=dict(type="str", required=False),
919 parent=dict(type="str", required=False),
920 vlan=dict(type="int", required=False),
921 bclim=dict(type="int", required=False),
922 no_default_route=dict(type="str", required=False),
923 vrf=dict(type="str", required=False),
924 bridge_name=dict(type="str", required=False),
925 driver_mtu=dict(type="str", required=False),
926 ),
927 ),
928 executable=dict(type="str", required=False, default="podman"),
929 debug=dict(type="bool", default=False),
930 recreate=dict(type="bool", default=False),
931 route=dict(type="list", elements="str", required=False),
932 quadlet_dir=dict(type="path", required=False),
933 quadlet_filename=dict(type="str", required=False),
934 quadlet_file_mode=dict(type="raw", required=False),
935 quadlet_options=dict(type="list", elements="str", required=False),
936 net_config=dict(
937 type="list",
938 required=False,
939 elements="dict",
940 options=dict(
941 subnet=dict(type="str", required=True),
942 gateway=dict(type="str", required=True),
943 ip_range=dict(type="str", required=False),
944 ),
945 ),
946 ),
947 required_by=dict( # for IP range and GW to set 'subnet' is required
948 ip_range=("subnet"),
949 gateway=("subnet"),
950 ),
951 # define or subnet or net config
952 mutually_exclusive=[["subnet", "net_config"]],
953 )
954
955 PodmanNetworkManager(module).execute()
956
957
958 if __name__ == "__main__":
959 main()