Debian Codegraph @

ansible_collections/netapp/storagegrid/plugins/modules/na_sg_org_user.py

raw
1 #!/usr/bin/python
2
3 # (c) 2020, NetApp Inc
4 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
5
6 """NetApp StorageGRID - Manage Tenant Users"""
7
8 from __future__ import absolute_import, division, print_function
9
10 __metaclass__ = type
11
12
13 ANSIBLE_METADATA = {
14 "metadata_version": "1.1",
15 "status": ["preview"],
16 "supported_by": "community",
17 }
18
19
20 DOCUMENTATION = """
21 module: na_sg_org_user
22 short_description: NetApp StorageGRID manage users within a tenancy.
23 extends_documentation_fragment:
24 - netapp.storagegrid.netapp.sg
25 version_added: '20.6.0'
26 author: NetApp Ansible Team (@joshedmonds) <[email protected]>
27 description:
28 - Create, Update, Delete Users within a NetApp StorageGRID tenant.
29 options:
30 state:
31 description:
32 - Whether the specified user should exist or not.
33 type: str
34 choices: ['present', 'absent']
35 default: present
36 full_name:
37 description:
38 - Full Name of the user.
39 - Required for create operation
40 type: str
41 unique_name:
42 description:
43 - Unique Name for the user. Must begin with C(user/) or C(federated-user/).
44 - Required for create, modify or delete operation.
45 type: str
46 required: true
47 member_of:
48 description:
49 - List of unique_groups that the user is a member of.
50 type: list
51 elements: str
52 password:
53 description:
54 - Set a password for a local user. Does not apply to federated users.
55 - Requires root privilege.
56 required: false
57 type: str
58 update_password:
59 description:
60 - Choose when to update the password.
61 - When set to C(always), the password will always be updated.
62 - When set to C(on_create), the password will only be set upon a new user creation.
63 default: on_create
64 choices:
65 - on_create
66 - always
67 type: str
68 disable:
69 description:
70 - Disable the user from signing in. Does not apply to federated users.
71 type: bool
72 """
73
74 EXAMPLES = """
75 - name: create a tenant user
76 netapp.storagegrid.na_sg_org_user:
77 api_url: "https://<storagegrid-endpoint-url>"
78 auth_token: "storagegrid-auth-token"
79 validate_certs: false
80 state: present
81 full_name: ansibleuser1
82 unique_name: user/ansibleuser1
83 member_of: "group/ansiblegroup1"
84 disable: false
85 """
86
87 RETURN = """
88 resp:
89 description: Returns information about the StorageGRID tenant user.
90 returned: always
91 type: dict
92 sample: {
93 "fullName": "Example User",
94 "memberOf": ["00000000-0000-0000-0000-000000000000"],
95 "disable": false,
96 "uniqueName": "user/Example",
97 "accountId": "0",
98 "id": "00000000-0000-0000-0000-000000000000",
99 "federated": false,
100 "userURN": "urn:sgws:identity::0:user/Example"
101 }
102 """
103
104 import re
105
106 import ansible_collections.netapp.storagegrid.plugins.module_utils.netapp as netapp_utils
107 from ansible.module_utils.basic import AnsibleModule
108 from ansible_collections.netapp.storagegrid.plugins.module_utils.netapp_module import (
109 NetAppModule,
110 )
111 from ansible_collections.netapp.storagegrid.plugins.module_utils.netapp import SGRestAPI
112
113
114 class SgOrgUser(object):
115 """
116 Create, modify and delete user within a StorageGRID Tenant Account
117 """
118
119 def __init__(self):
120 """
121 Parse arguments, setup state variables,
122 check parameters and ensure request module is installed
123 """
124 self.argument_spec = netapp_utils.na_storagegrid_host_argument_spec()
125 self.argument_spec.update(
126 dict(
127 state=dict(required=False, type="str", choices=["present", "absent"], default="present"),
128 full_name=dict(required=False, type="str"),
129 unique_name=dict(required=True, type="str"),
130 member_of=dict(required=False, type="list", elements="str"),
131 disable=dict(required=False, type="bool"),
132 password=dict(required=False, type="str", no_log=True),
133 update_password=dict(default="on_create", choices=["on_create", "always"]),
134 )
135 )
136
137 self.module = AnsibleModule(
138 argument_spec=self.argument_spec,
139 required_if=[("state", "present", ["full_name", "unique_name"])],
140 supports_check_mode=True,
141 )
142
143 self.na_helper = NetAppModule()
144
145 # set up state variables
146 self.parameters = self.na_helper.set_parameters(self.module.params)
147 # Calling generic SG rest_api class
148 self.rest_api = SGRestAPI(self.module)
149 # Get API version
150 self.rest_api.get_sg_product_version(api_root="org")
151 self.api_version = self.rest_api.get_api_version()
152
153 # Checking for the parameters passed and create new parameters list
154 self.data = {}
155 self.data["memberOf"] = []
156 if self.parameters.get("full_name"):
157 self.data["fullName"] = self.parameters["full_name"]
158 if self.parameters.get("unique_name"):
159 self.data["uniqueName"] = self.parameters["unique_name"]
160
161 if self.parameters.get("disable") is not None:
162 self.data["disable"] = self.parameters["disable"]
163
164 re_local_user = re.compile("^user/")
165 re_fed_user = re.compile("^federated-user/")
166
167 if (
168 re_local_user.match(self.parameters["unique_name"]) is None
169 and re_fed_user.match(self.parameters["unique_name"]) is None
170 ):
171 self.module.fail_json(msg="unique_name must begin with 'user/' or 'federated-user/'")
172
173 self.pw_change = {}
174 if self.parameters.get("password") is not None:
175 if re_fed_user.match(self.parameters["unique_name"]):
176 self.module.fail_json(msg="password cannot be set for a federated user")
177 self.pw_change["password"] = self.parameters["password"]
178
179 def get_org_groups(self):
180 # Get list of groups
181 # Retrun mapping of uniqueName to ids if found, or None
182 api = "api/%s/org/groups?limit=350" % self.api_version
183 response, error = self.rest_api.get(api)
184
185 if error:
186 self.module.fail_json(msg=error)
187
188 if response["data"]:
189 name_to_id_map = dict(
190 zip(
191 [i["uniqueName"] for i in response["data"]],
192 [j["id"] for j in response["data"]],
193 )
194 )
195 return name_to_id_map
196
197 return None
198
199 def get_org_user(self, unique_name):
200 # Use the unique name to check if the user exists
201 api = "api/%s/org/users/%s" % (self.api_version, unique_name)
202 response, error = self.rest_api.get(api)
203
204 if error:
205 if response["code"] != 404:
206 self.module.fail_json(msg=error)
207 else:
208 return response["data"]
209 return None
210
211 def create_org_user(self):
212 api = "api/%s/org/users" % self.api_version
213
214 response, error = self.rest_api.post(api, self.data)
215
216 if error:
217 self.module.fail_json(msg=error)
218
219 return response["data"]
220
221 def delete_org_user(self, user_id):
222 api = "api/%s/org/users/%s" % (self.api_version, user_id)
223
224 self.data = None
225 response, error = self.rest_api.delete(api, self.data)
226 if error:
227 self.module.fail_json(msg=error)
228
229 def update_org_user(self, user_id):
230 api = "api/%s/org/users/%s" % (self.api_version, user_id)
231
232 response, error = self.rest_api.put(api, self.data)
233 if error:
234 self.module.fail_json(msg=error)
235
236 return response["data"]
237
238 def set_org_user_password(self, unique_name):
239 api = "api/%s/org/users/%s/change-password" % (self.api_version, unique_name)
240 response, error = self.rest_api.post(api, self.pw_change)
241
242 if error:
243 self.module.fail_json(msg=error)
244
245 def apply(self):
246 """
247 Perform pre-checks, call functions and exit
248 """
249 org_user = self.get_org_user(self.parameters["unique_name"])
250
251 if self.parameters.get("member_of"):
252 org_groups = self.get_org_groups()
253 try:
254 self.data["memberOf"] = [org_groups[x] for x in self.parameters["member_of"]]
255 except KeyError as e:
256 self.module.fail_json(msg="Invalid unique_group supplied: '%s' not found" % e.args[0])
257
258 cd_action = self.na_helper.get_cd_action(org_user, self.parameters)
259
260 if cd_action is None and self.parameters["state"] == "present":
261 # let's see if we need to update parameters
262 update = False
263
264 if org_user.get("memberOf") is None:
265 if self.data.get("memberOf"):
266 member_of_diff = [self.data['memberOf']]
267 else:
268 member_of_diff = []
269 else:
270 member_of_diff = [
271 i
272 for i in self.data["memberOf"] + org_user["memberOf"]
273 if i not in self.data["memberOf"] or i not in org_user["memberOf"]
274 ]
275 if member_of_diff:
276 update = True
277
278 if self.parameters.get("disable") is not None and self.parameters["disable"] != org_user.get("disable"):
279 update = True
280
281 if update:
282 self.na_helper.changed = True
283
284 result_message = ""
285 resp_data = org_user
286 if self.na_helper.changed:
287 if self.module.check_mode:
288 pass
289 else:
290 if cd_action == "delete":
291 self.delete_org_user(org_user["id"])
292 result_message = "Org User deleted"
293
294 elif cd_action == "create":
295 resp_data = self.create_org_user()
296 result_message = "Org User created"
297
298 else:
299 resp_data = self.update_org_user(org_user["id"])
300 result_message = "Org User updated"
301
302 # If a password has been set
303 if self.pw_change:
304 if self.module.check_mode:
305 pass
306 else:
307 # Only update the password if update_password is always, or a create activity has occurred
308 if cd_action == "create" or self.parameters["update_password"] == "always":
309 self.set_org_user_password(self.parameters["unique_name"])
310 self.na_helper.changed = True
311
312 results = [result_message, "Org User password updated"]
313 result_message = "; ".join(filter(None, results))
314
315 self.module.exit_json(changed=self.na_helper.changed, msg=result_message, resp=resp_data)
316
317
318 def main():
319 """
320 Main function
321 """
322 na_sg_org_user = SgOrgUser()
323 na_sg_org_user.apply()
324
325
326 if __name__ == "__main__":
327 main()