Debian Codegraph @

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

raw
1 #!/usr/bin/python
2 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
3
4 from __future__ import absolute_import, division, print_function
5
6 __metaclass__ = type
7
8
9 DOCUMENTATION = r"""
10 ---
11 module: podman_secret
12 author:
13 - "Aliaksandr Mianzhynski (@amenzhinsky)"
14 version_added: '1.7.0'
15 short_description: Manage podman secrets
16 notes: []
17 description:
18 - Manage podman secrets
19 requirements:
20 - podman
21 options:
22 data:
23 description:
24 - The value of the secret. Required when C(state) is C(present).
25 Mutually exclusive with C(env) and C(path).
26 type: str
27 driver:
28 description:
29 - Override default secrets driver, currently podman uses C(file)
30 which is unencrypted.
31 type: str
32 driver_opts:
33 description:
34 - Driver-specific key-value options.
35 type: dict
36 env:
37 description:
38 - The name of the environment variable that contains the secret.
39 Mutually exclusive with C(data) and C(path).
40 type: str
41 executable:
42 description:
43 - Path to C(podman) executable if it is not in the C($PATH) on the
44 machine running C(podman)
45 type: str
46 default: 'podman'
47 force:
48 description:
49 - Use it when C(state) is C(present) to remove and recreate an existing secret.
50 type: bool
51 default: false
52 skip_existing:
53 description:
54 - Use it when C(state) is C(present) and secret with the same name already exists.
55 If set to C(true), the secret will NOT be recreated and remains as is.
56 type: bool
57 default: false
58 name:
59 description:
60 - The name of the secret.
61 required: True
62 type: str
63 path:
64 description:
65 - Path to the file that contains the secret.
66 Mutually exclusive with C(data) and C(env).
67 type: path
68 state:
69 description:
70 - Whether to create or remove the named secret.
71 type: str
72 default: present
73 choices:
74 - absent
75 - present
76 labels:
77 description:
78 - Labels to set on the secret.
79 type: dict
80 debug:
81 description:
82 - Enable debug mode for module. It prints secrets diff.
83 type: bool
84 default: False
85 """
86
87 EXAMPLES = r"""
88 - name: Create secret
89 containers.podman.podman_secret:
90 state: present
91 name: mysecret
92 data: "my super secret content"
93
94 - name: Create container that uses the secret
95 containers.podman.podman_container:
96 name: showmysecret
97 image: docker.io/alpine:3.14
98 secrets:
99 - mysecret
100 detach: false
101 command: cat /run/secrets/mysecret
102 register: container
103
104 - name: Output secret data
105 debug:
106 msg: '{{ container.stdout }}'
107
108 - name: Remove secret
109 containers.podman.podman_secret:
110 state: absent
111 name: mysecret
112 """
113
114 import os
115
116 from ansible.module_utils.basic import AnsibleModule
117 from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
118 LooseVersion,
119 )
120 from ansible_collections.containers.podman.plugins.module_utils.podman.common import (
121 get_podman_version,
122 )
123
124 diff = {"before": "", "after": ""}
125
126
127 def podman_secret_exists(module, executable, name, version):
128 if version is None or LooseVersion(version) < LooseVersion("4.5.0"):
129 rc, out, err = module.run_command([executable, "secret", "ls", "--format", "{{.Name}}"])
130 return name in [i.strip() for i in out.splitlines()]
131 rc, out, err = module.run_command([executable, "secret", "exists", name])
132 return rc == 0
133
134
135 def need_update(module, executable, name, data, path, env, skip, driver, driver_opts, debug, labels):
136 cmd = [executable, "secret", "inspect", "--showsecret", name]
137 rc, out, err = module.run_command(cmd)
138 if rc != 0:
139 if debug:
140 module.log("PODMAN-SECRET-DEBUG: Unable to get secret info: %s" % err)
141 return True
142 if skip:
143 return False
144 try:
145 secret = module.from_json(out)[0]
146 if data is not None:
147 if secret["SecretData"] != data:
148 if debug:
149 diff["after"] = data
150 diff["before"] = secret["SecretData"]
151 else:
152 diff["after"] = "<different-secret>"
153 diff["before"] = "<secret>"
154 return True
155 if path:
156 with open(path, "rb") as f:
157 text = f.read().decode("utf-8")
158 if secret["SecretData"] != text:
159 if debug:
160 diff["after"] = text
161 diff["before"] = secret["SecretData"]
162 else:
163 diff["after"] = "<different-secret>"
164 diff["before"] = "<secret>"
165 return True
166 if env:
167 env_data = os.environ.get(env)
168 if secret["SecretData"] != env_data:
169 if debug:
170 diff["after"] = env_data
171 diff["before"] = secret["SecretData"]
172 else:
173 diff["after"] = "<different-secret>"
174 diff["before"] = "<secret>"
175 return True
176 if driver:
177 if secret["Spec"]["Driver"]["Name"] != driver:
178 diff["after"] = driver
179 diff["before"] = secret["Spec"]["Driver"]["Name"]
180 return True
181 if driver_opts:
182 for k, v in driver_opts.items():
183 if secret["Spec"]["Driver"]["Options"].get(k) != v:
184 diff["after"] = "=".join([k, v])
185 diff["before"] = "=".join([k, secret["Spec"]["Driver"]["Options"].get(k)])
186 return True
187 if labels:
188 for k, v in labels.items():
189 if secret["Spec"]["Labels"].get(k) != v:
190 diff["after"] = "=".join([k, v])
191 diff["before"] = "=".join([k, secret["Spec"]["Labels"].get(k)])
192 return True
193 except Exception:
194 return True
195 return False
196
197
198 def podman_secret_create(
199 module,
200 executable,
201 name,
202 data,
203 path,
204 env,
205 force,
206 skip,
207 driver,
208 driver_opts,
209 debug,
210 labels,
211 ):
212 podman_version = get_podman_version(module, fail=False)
213 if podman_version is not None and LooseVersion(podman_version) >= LooseVersion("4.7.0"):
214 if need_update(
215 module,
216 executable,
217 name,
218 data,
219 path,
220 env,
221 skip,
222 driver,
223 driver_opts,
224 debug,
225 labels,
226 ):
227 podman_secret_remove(module, executable, name)
228 else:
229 return {"changed": False}
230 else:
231 if force:
232 podman_secret_remove(module, executable, name)
233 if skip and podman_secret_exists(module, executable, name, podman_version):
234 return {"changed": False}
235
236 cmd = [executable, "secret", "create"]
237 if driver:
238 cmd.append("--driver")
239 cmd.append(driver)
240 if driver_opts:
241 cmd.append("--driver-opts")
242 cmd.append(",".join("=".join(i) for i in driver_opts.items()))
243 if labels:
244 for k, v in labels.items():
245 cmd.append("--label")
246 cmd.append("=".join([k, v]))
247 cmd.append(name)
248 if data is not None:
249 cmd.append("-")
250 elif path:
251 cmd.append(path)
252 elif env:
253 if os.environ.get(env) is None:
254 module.fail_json(msg="Environment variable %s is not set" % env)
255 cmd.append("--env")
256 cmd.append(env)
257
258 if data is not None:
259 rc, out, err = module.run_command(cmd, data=data, binary_data=True)
260 else:
261 rc, out, err = module.run_command(cmd)
262 if rc != 0:
263 module.fail_json(msg="Unable to create secret: %s" % err)
264
265 return {
266 "changed": True,
267 "diff": {
268 "before": diff["before"] + "\n",
269 "after": diff["after"] + "\n",
270 },
271 }
272
273
274 def podman_secret_remove(module, executable, name):
275 changed = False
276 rc, out, err = module.run_command([executable, "secret", "rm", name])
277 if rc == 0:
278 changed = True
279 elif "no such secret" in err:
280 pass
281 else:
282 module.fail_json(msg="Unable to remove secret: %s" % err)
283
284 return {
285 "changed": changed,
286 }
287
288
289 def main():
290 module = AnsibleModule(
291 argument_spec=dict(
292 executable=dict(type="str", default="podman"),
293 state=dict(type="str", default="present", choices=["absent", "present"]),
294 name=dict(type="str", required=True),
295 data=dict(type="str", no_log=True),
296 env=dict(type="str"),
297 path=dict(type="path"),
298 force=dict(type="bool", default=False),
299 skip_existing=dict(type="bool", default=False),
300 driver=dict(type="str"),
301 driver_opts=dict(type="dict"),
302 labels=dict(type="dict"),
303 debug=dict(type="bool", default=False),
304 ),
305 required_if=[("state", "present", ["path", "env", "data"], True)],
306 mutually_exclusive=[["path", "env", "data"]],
307 )
308
309 state = module.params["state"]
310 name = module.params["name"]
311 executable = module.get_bin_path(module.params["executable"], required=True)
312
313 if state == "present":
314 data = module.params["data"]
315 force = module.params["force"]
316 skip = module.params["skip_existing"]
317 driver = module.params["driver"]
318 driver_opts = module.params["driver_opts"]
319 debug = module.params["debug"]
320 labels = module.params["labels"]
321 path = module.params["path"]
322 env = module.params["env"]
323 results = podman_secret_create(
324 module,
325 executable,
326 name,
327 data,
328 path,
329 env,
330 force,
331 skip,
332 driver,
333 driver_opts,
334 debug,
335 labels,
336 )
337 else:
338 results = podman_secret_remove(module, executable, name)
339
340 module.exit_json(**results)
341
342
343 if __name__ == "__main__":
344 main()