Debian Codegraph @

ansible_collections/netapp/storagegrid/plugins/modules/na_sg_grid_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 Grid-administration 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_grid_user
22 short_description: NetApp StorageGRID manage users.
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 Administrative Users within NetApp StorageGRID.
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 C(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 user
76 netapp.storagegrid.na_sg_grid_user:
77 api_url: "https://<storagegrid-endpoint-url>"
78 auth_token: "storagegrid-auth-token"
79 validate_certs: false
80 state: present
81 full_name: ansibleuser100
82 unique_name: user/ansibleuser100
83 member_of: "group/ansiblegroup100"
84 disable: false
85 """
86
87 RETURN = """
88 resp:
89 description: Returns information about the StorageGRID Grid 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 NetAppModule
109 from ansible_collections.netapp.storagegrid.plugins.module_utils.netapp import SGRestAPI
110
111
112 class SgGridUser(object):
113 """
114 Create, modify and delete user within a StorageGRID Tenant Account
115 """
116
117 def __init__(self):
118 """
119 Parse arguments, setup state variables,
120 check parameters and ensure request module is installed
121 """
122 self.argument_spec = netapp_utils.na_storagegrid_host_argument_spec()
123 self.argument_spec.update(
124 dict(
125 state=dict(required=False, type="str", choices=["present", "absent"], default="present"),
126 full_name=dict(required=False, type="str"),
127 unique_name=dict(required=True, type="str"),
128 member_of=dict(required=False, type="list", elements="str"),
129 disable=dict(required=False, type="bool"),
130 password=dict(required=False, type="str", no_log=True),
131 update_password=dict(default="on_create", choices=["on_create", "always"]),
132 )
133 )
134
135 self.module = AnsibleModule(
136 argument_spec=self.argument_spec,
137 required_if=[("state", "present", ["full_name", "unique_name"])],
138 supports_check_mode=True,
139 )
140
141 self.na_helper = NetAppModule()
142
143 # set up state variables
144 self.parameters = self.na_helper.set_parameters(self.module.params)
145 # Calling generic SG rest_api class
146 self.rest_api = SGRestAPI(self.module)
147 # Get API version
148 self.rest_api.get_sg_product_version()
149 self.api_version = self.rest_api.get_api_version()
150
151 # Checking for the parameters passed and create new parameters list
152 self.data = {}
153 self.data["memberOf"] = []
154 if self.parameters.get("full_name"):
155 self.data["fullName"] = self.parameters["full_name"]
156 if self.parameters.get("unique_name"):
157 self.data["uniqueName"] = self.parameters["unique_name"]
158
159 if self.parameters.get("disable") is not None:
160 self.data["disable"] = self.parameters["disable"]
161
162 re_local_user = re.compile("^user/")
163 re_fed_user = re.compile("^federated-user/")
164
165 if (
166 re_local_user.match(self.parameters["unique_name"]) is None
167 and re_fed_user.match(self.parameters["unique_name"]) is None
168 ):
169 self.module.fail_json(msg="unique_name must begin with 'user/' or 'federated-user/'")
170
171 self.pw_change = {}
172 if self.parameters.get("password") is not None:
173 if re_fed_user.match(self.parameters["unique_name"]):
174 self.module.fail_json(msg="password cannot be set for a federated user")
175 self.pw_change["password"] = self.parameters["password"]
176
177 def get_grid_groups(self):
178 # Get list of admin groups
179 # Retrun mapping of uniqueName to ids if found, or None
180 api = "api/%s/grid/groups?limit=350" % self.api_version
181
182 response, error = self.rest_api.get(api)
183
184 if error:
185 self.module.fail_json(msg=error)
186
187 if response["data"]:
188 name_to_id_map = dict(zip([i["uniqueName"] for i in response["data"]], [j["id"] for j in response["data"]]))
189 return name_to_id_map
190
191 return None
192
193 def get_grid_user(self, unique_name):
194 # Use the unique name to check if the user exists
195 api = "api/%s/grid/users/%s" % (self.api_version, unique_name)
196 response, error = self.rest_api.get(api)
197
198 if error:
199 if response["code"] != 404:
200 self.module.fail_json(msg=error)
201 else:
202 return response["data"]
203 return None
204
205 def create_grid_user(self):
206 api = "api/%s/grid/users" % self.api_version
207
208 response, error = self.rest_api.post(api, self.data)
209
210 if error:
211 self.module.fail_json(msg=error)
212
213 return response["data"]
214
215 def delete_grid_user(self, user_id):
216 api = "api/%s/grid/users/%s" % (self.api_version, user_id)
217
218 self.data = None
219 response, error = self.rest_api.delete(api, self.data)
220 if error:
221 self.module.fail_json(msg=error)
222
223 def update_grid_user(self, user_id):
224 api = "api/%s/grid/users/%s" % (self.api_version, user_id)
225
226 response, error = self.rest_api.put(api, self.data)
227 if error:
228 self.module.fail_json(msg=error)
229
230 return response["data"]
231
232 def set_grid_user_password(self, unique_name):
233 api = "api/%s/grid/users/%s/change-password" % (self.api_version, unique_name)
234 response, error = self.rest_api.post(api, self.pw_change)
235
236 if error:
237 self.module.fail_json(msg=error)
238
239 def apply(self):
240 """
241 Perform pre-checks, call functions and exit
242 """
243 grid_user = self.get_grid_user(self.parameters["unique_name"])
244
245 if self.parameters.get("member_of"):
246 grid_groups = self.get_grid_groups()
247 try:
248 self.data["memberOf"] = [grid_groups[x] for x in self.parameters["member_of"]]
249 except KeyError as e:
250 self.module.fail_json(msg="Invalid unique_group supplied: '%s' not found" % e.args[0])
251
252 cd_action = self.na_helper.get_cd_action(grid_user, self.parameters)
253
254 if cd_action is None and self.parameters["state"] == "present":
255 # let's see if we need to update parameters
256 update = False
257
258 if grid_user["memberOf"] is None:
259 member_of_diff = []
260 else:
261 member_of_diff = [
262 i
263 for i in self.data["memberOf"] + grid_user["memberOf"]
264 if i not in self.data["memberOf"] or i not in grid_user["memberOf"]
265 ]
266 if member_of_diff:
267 update = True
268
269 if self.parameters.get("disable") is not None and self.parameters["disable"] != grid_user.get("disable"):
270 update = True
271
272 if update:
273 self.na_helper.changed = True
274 result_message = ""
275 resp_data = grid_user
276 if self.na_helper.changed:
277 if self.module.check_mode:
278 pass
279 else:
280 if cd_action == "delete":
281 self.delete_grid_user(grid_user["id"])
282 result_message = "Grid User deleted"
283
284 elif cd_action == "create":
285 resp_data = self.create_grid_user()
286 result_message = "Grid User created"
287
288 else:
289 resp_data = self.update_grid_user(grid_user["id"])
290 result_message = "Grid User updated"
291
292 # If a password has been set
293 if self.pw_change:
294 if self.module.check_mode:
295 pass
296 else:
297 # Only update the password if update_password is always, or a create activity has occurred
298 if cd_action == "create" or self.parameters["update_password"] == "always":
299 self.set_grid_user_password(self.parameters["unique_name"])
300 self.na_helper.changed = True
301
302 results = [result_message, "Grid User password updated"]
303 result_message = "; ".join(filter(None, results))
304
305 self.module.exit_json(changed=self.na_helper.changed, msg=result_message, resp=resp_data)
306
307
308 def main():
309 """
310 Main function
311 """
312 na_sg_grid_user = SgGridUser()
313 na_sg_grid_user.apply()
314
315
316 if __name__ == "__main__":
317 main()