Debian Codegraph @

ansible_collections/netapp/ontap/plugins/modules/na_ontap_user_role.py

raw
1 #!/usr/bin/python
2
3 # (c) 2018-2026, NetApp, Inc
4 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
5
6 from __future__ import absolute_import, division, print_function
7 __metaclass__ = type
8
9
10 DOCUMENTATION = '''
11
12 module: na_ontap_user_role
13
14 short_description: NetApp ONTAP user role configuration and management
15 extends_documentation_fragment:
16 - netapp.ontap.netapp.na_ontap
17 version_added: 2.6.0
18 author: NetApp Ansible Team (@carchi8py) <[email protected]>
19
20 description:
21 - Create, modify, or destroy user roles.
22
23 options:
24
25 state:
26 description:
27 - Whether the specified user role should exist or not.
28 choices: ['present', 'absent']
29 type: str
30 default: present
31
32 name:
33 description:
34 - The name of the role to manage.
35 required: true
36 type: str
37
38 command_directory_name:
39 description:
40 - The command or command directory to which the role has an access.
41 - Required with ZAPI.
42 - Use C(privileges) for rest-role path choices.
43 type: str
44
45 access_level:
46 description:
47 - The access level of the role. Defaults to 'all'.
48 - Use C(privileges) for rest-role access choices.
49 choices: ['none', 'readonly', 'all']
50 type: str
51
52 query:
53 description:
54 - A query for the role. The query must apply to the specified command or directory name.
55 - Use double quotes "" for modifying a existing query to none.
56 - Use C(privileges) for rest-role query choices.
57 type: str
58 version_added: 2.8.0
59
60 privileges:
61 description:
62 - Privileges to give the user roles
63 - REST only
64 type: list
65 elements: dict
66 version_added: 21.23.0
67 suboptions:
68 query:
69 description:
70 - A query for the role. The query must apply to the specified command or directory name.
71 - Query is only supported on 9.11.1+
72 type: str
73 access:
74 description:
75 - The access level of the role.
76 - For command/command directory path, the only supported enum values are 'none','readonly' and 'all'.
77 - Options 'read_create', 'read_modify' and 'read_create_modify' are supported only with REST and requires ONTAP 9.11.1 or later versions.
78 choices: ['none', 'readonly', 'all', 'read_create', 'read_modify', 'read_create_modify']
79 default: all
80 type: str
81 path:
82 description:
83 - The api or command to which the role has an access.
84 - command or command directory path is supported from ONTAP 9.11.1 or later versions.
85 - Only rest roles are supported for earlier versions.
86 type: str
87 required: true
88
89 vserver:
90 description:
91 - The name of the vserver to use.
92 - Required with ZAPI.
93 type: str
94
95 notes:
96 - supports ZAPI and REST. REST requires ONTAP 9.7 or later.
97 - supports check mode.
98 - when trying to add a command to a role, ONTAP will affect other related commands too.
99 - for example, 'volume modify' will affect 'volume create' and 'volume show', always provide all the related commands.
100 - REST supports both role and rest-role from ONTAP 9.11.1 or later versions and only rest-role for earlier versions.
101 '''
102
103 EXAMPLES = """
104 - name: Create User Role Zapi
105 netapp.ontap.na_ontap_user_role:
106 state: present
107 name: ansibleRole
108 command_directory_name: volume
109 access_level: none
110 query: show
111 vserver: ansibleVServer
112 use_rest: never
113 hostname: "{{ netapp_hostname }}"
114 username: "{{ netapp_username }}"
115 password: "{{ netapp_password }}"
116
117 - name: Modify User Role Zapi
118 netapp.ontap.na_ontap_user_role:
119 state: present
120 name: ansibleRole
121 command_directory_name: volume
122 access_level: none
123 query: ""
124 vserver: ansibleVServer
125 use_rest: never
126 hostname: "{{ netapp_hostname }}"
127 username: "{{ netapp_username }}"
128 password: "{{ netapp_password }}"
129
130 - name: Create user role REST in ONTAP 9.11.1
131 netapp.ontap.na_ontap_user_role:
132 state: present
133 privileges:
134 - path: /api/cluster/jobs
135 vserver: ansibleSVM
136 name: carchi-test-role
137 hostname: "{{ netapp_hostname }}"
138 username: "{{ netapp_username }}"
139 password: "{{ netapp_password }}"
140
141 - name: Modify user role REST in ONTAP 9.11.1
142 netapp.ontap.na_ontap_user_role:
143 state: present
144 privileges:
145 - path: /api/cluster/jobs
146 access: readonly
147 - path: /api/storage/volumes
148 access: readonly
149 vserver: ansibleSVM
150 name: carchi-test-role
151 hostname: "{{ netapp_hostname }}"
152 username: "{{ netapp_username }}"
153 password: "{{ netapp_password }}"
154
155 - name: Create user role REST in ONTAP 9.11.1+ with query
156 netapp.ontap.na_ontap_user_role:
157 state: present
158 privileges:
159 - path: job schedule interval
160 access: all
161 query: "-days <1 -hours >12"
162 vserver: ansibleSVM
163 name: carchi-test-role
164 hostname: "{{ netapp_hostname }}"
165 username: "{{ netapp_username }}"
166 password: "{{ netapp_password }}"
167
168 - name: Modify user role REST in ONTAP 9.11.1+ with query
169 netapp.ontap.na_ontap_user_role:
170 state: present
171 privileges:
172 - path: job schedule interval
173 access: readonly
174 query: "-days <1 -hours >8"
175 vserver: ansibleSVM
176 name: carchi-test-role
177 hostname: "{{ netapp_hostname }}"
178 username: "{{ netapp_username }}"
179 password: "{{ netapp_password }}"
180 """
181
182 RETURN = """
183
184 """
185 import traceback
186
187 from ansible.module_utils.basic import AnsibleModule
188 from ansible.module_utils._text import to_native
189 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
190 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
191 from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic
192 from operator import itemgetter
193
194
195 class NetAppOntapUserRole:
196
197 def __init__(self):
198 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
199 self.argument_spec.update(dict(
200 state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
201 name=dict(required=True, type='str'),
202 command_directory_name=dict(required=False, type='str'),
203 access_level=dict(required=False, type='str',
204 choices=['none', 'readonly', 'all']),
205 vserver=dict(required=False, type='str'),
206 query=dict(required=False, type='str'),
207 privileges=dict(required=False, type='list', elements='dict', options=dict(
208 query=dict(required=False, type='str'),
209 access=dict(required=False, type='str', default='all',
210 choices=['none', 'readonly', 'all', 'read_create', 'read_modify', 'read_create_modify']),
211 path=dict(required=True, type='str')
212 ))
213 ))
214
215 self.module = AnsibleModule(
216 argument_spec=self.argument_spec,
217 supports_check_mode=True,
218 mutually_exclusive=[('command_directory_name', 'privileges'),
219 ('access_level', 'privileges'),
220 ('query', 'privileges')]
221 )
222 self.owner_uuid = None
223 self.role_modified = None
224 self.na_helper = NetAppModule()
225 self.parameters = self.na_helper.set_parameters(self.module.params)
226 if self.parameters.get('privileges') is not None and self.parameters['state'] == 'present':
227 self.parameters['privileges'] = self.na_helper.filter_out_none_entries(self.parameters['privileges'])
228 for privilege in self.parameters['privileges']:
229 path = privilege.get('path', '')
230 if path == 'DEFAULT' or path.startswith('/api/'):
231 had_query = 'query' in privilege
232 privilege.pop('query', None)
233 path_type = 'DEFAULT path' if path == 'DEFAULT' else 'API endpoint'
234 if had_query:
235 self.module.warn('Warning: Query parameter is not supported for %s type, removing it from the request.' % (path_type))
236 else:
237 # Treat explicit empty string as a request to clear query while
238 # leaving an omitted query unmanaged for idempotent comparisons.
239 if 'query' in privilege:
240 if privilege.get('query') is None:
241 privilege.pop('query', None)
242 elif privilege.get('query') in ['', '-']:
243 privilege['query'] = None
244 self.rest_api = netapp_utils.OntapRestAPI(self.module)
245 unsupported_rest_properties = ['command_directory_name', 'access_level']
246 # Check if any privilege uses query feature that requires 9.11.1+
247 has_query = any(priv.get('query') and priv['query'] != '' for priv in self.parameters.get('privileges', []))
248
249 partially_supported_rest_properties = [['privileges.query', (9, 11, 1)]] if has_query else []
250
251 self.use_rest = self.rest_api.is_rest_supported_properties(self.parameters, unsupported_rest_properties, partially_supported_rest_properties)
252 unsupported_zapi_properties = ['privileges']
253 if self.use_rest and not self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 7, 0):
254 msg = 'REST requires ONTAP 9.7 or later for security/roles APIs.'
255 self.use_rest = self.na_helper.fall_back_to_zapi(self.module, msg, self.parameters)
256 if not self.use_rest:
257 if netapp_utils.has_netapp_lib() is False:
258 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
259 if not self.parameters.get('vserver'):
260 self.module.fail_json(msg="Error: vserver is a required field with ZAPI.")
261 if not self.parameters.get('command_directory_name'):
262 self.module.fail_json(msg="Error: command_directory_name is a required field with ZAPI.")
263 if not self.parameters.get('access_level'):
264 self.parameters['access_level'] = 'all'
265 for unsupported_prop in unsupported_zapi_properties:
266 if self.parameters.get(unsupported_prop) is not None:
267 self.module.fail_json(msg="Error: %s option is not supported with ZAPI. It can only be used with REST. use_rest: %s." %
268 (unsupported_prop, self.parameters.get('use_rest')))
269 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
270 elif not self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 11, 1) and self.parameters['state'] == 'present':
271 self.validate_rest_path()
272
273 def validate_rest_path(self):
274 """REST does not support command or command directory path in ONTAP < 9.11.1 versions."""
275 invalid_uri = [priv['path'] for priv in self.parameters.get('privileges', []) if '/' not in priv['path']]
276 if invalid_uri:
277 self.module.fail_json(msg="Error: Invalid URI %s, please set valid REST API path" % invalid_uri)
278
279 def get_role(self):
280 """
281 Checks if the role exists for specific command-directory-name.
282
283 :return:
284 True if role found
285 False if role is not found
286 :rtype: bool
287 """
288 if self.use_rest:
289 return self.get_role_rest()
290 options = {'vserver': self.parameters['vserver'],
291 'role-name': self.parameters['name'],
292 'command-directory-name': self.parameters['command_directory_name']}
293 security_login_role_get_iter = netapp_utils.zapi.NaElement(
294 'security-login-role-get-iter')
295 query_details = netapp_utils.zapi.NaElement.create_node_with_children(
296 'security-login-role-info', **options)
297 query = netapp_utils.zapi.NaElement('query')
298 query.add_child_elem(query_details)
299 security_login_role_get_iter.add_child_elem(query)
300
301 try:
302 result = self.server.invoke_successfully(
303 security_login_role_get_iter, enable_tunneling=False)
304 except netapp_utils.zapi.NaApiError as e:
305 # Error 16031 denotes a role not being found.
306 if to_native(e.code) == "16031":
307 return None
308 # Error 16039 denotes command directory not found.
309 elif to_native(e.code) == "16039":
310 return None
311 else:
312 self.module.fail_json(msg='Error getting role %s: %s' % (self.parameters['name'], to_native(e)),
313 exception=traceback.format_exc())
314 if (result.get_child_by_name('num-records') and
315 int(result.get_child_content('num-records')) >= 1):
316 role_info = result.get_child_by_name('attributes-list').get_child_by_name('security-login-role-info')
317 result = {
318 'name': role_info['role-name'],
319 'access_level': role_info['access-level'],
320 'command_directory_name': role_info['command-directory-name'],
321 'query': role_info['role-query']
322 }
323 return result
324 return None
325
326 def create_role(self):
327 if self.use_rest:
328 return self.create_role_rest()
329 options = {'vserver': self.parameters['vserver'],
330 'role-name': self.parameters['name'],
331 'command-directory-name': self.parameters['command_directory_name'],
332 'access-level': self.parameters['access_level']}
333 if self.parameters.get('query'):
334 options['role-query'] = self.parameters['query']
335 role_create = netapp_utils.zapi.NaElement.create_node_with_children('security-login-role-create', **options)
336
337 try:
338 self.server.invoke_successfully(role_create,
339 enable_tunneling=False)
340 except netapp_utils.zapi.NaApiError as error:
341 self.module.fail_json(msg='Error creating role %s: %s' % (self.parameters['name'], to_native(error)),
342 exception=traceback.format_exc())
343
344 def delete_role(self):
345 if self.use_rest:
346 return self.delete_role_rest()
347 role_delete = netapp_utils.zapi.NaElement.create_node_with_children(
348 'security-login-role-delete', **{'vserver': self.parameters['vserver'],
349 'role-name': self.parameters['name'],
350 'command-directory-name':
351 self.parameters['command_directory_name']})
352
353 try:
354 self.server.invoke_successfully(role_delete,
355 enable_tunneling=False)
356 except netapp_utils.zapi.NaApiError as error:
357 self.module.fail_json(msg='Error removing role %s: %s' % (self.parameters['name'], to_native(error)),
358 exception=traceback.format_exc())
359
360 def modify_role(self, modify):
361 if self.use_rest:
362 return self.modify_role_rest(modify)
363 options = {'vserver': self.parameters['vserver'],
364 'role-name': self.parameters['name'],
365 'command-directory-name': self.parameters['command_directory_name']}
366 if 'access_level' in modify.keys():
367 options['access-level'] = self.parameters['access_level']
368 if 'query' in modify.keys():
369 options['role-query'] = self.parameters['query']
370
371 role_modify = netapp_utils.zapi.NaElement.create_node_with_children('security-login-role-modify', **options)
372
373 try:
374 self.server.invoke_successfully(role_modify,
375 enable_tunneling=False)
376 except netapp_utils.zapi.NaApiError as error:
377 self.module.fail_json(msg='Error modifying role %s: %s' % (self.parameters['name'], to_native(error)),
378 exception=traceback.format_exc())
379
380 def get_role_rest(self):
381 api = 'security/roles'
382 if self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 11, 1):
383 fields = 'name,owner,privileges.path,privileges.access,privileges.query'
384 else:
385 fields = 'name,owner,privileges.path,privileges.access'
386 params = {'name': self.parameters['name'],
387 'fields': fields}
388 if self.parameters.get('vserver'):
389 params['owner.name'] = self.parameters['vserver']
390 else:
391 params['scope'] = 'cluster'
392 record, error = rest_generic.get_one_record(self.rest_api, api, params)
393 if error:
394 self.module.fail_json(msg="Error getting role %s: %s" % (self.parameters['name'], to_native(error)),
395 exception=traceback.format_exc())
396 return self.format_record(record)
397
398 def format_record(self, record):
399 if not record:
400 return None
401
402 desired_manages_default = any(
403 privilege.get('path') == 'DEFAULT' for privilege in self.parameters.get('privileges', [])
404 )
405 desired_by_path = {
406 privilege['path']: privilege for privilege in self.parameters.get('privileges', [])
407 if privilege.get('path')
408 }
409
410 normalized_privileges = []
411 for each in self.na_helper.safe_get(record, ['privileges']):
412 each = dict(each)
413 if each.get('_links'):
414 each.pop('_links')
415 # DEFAULT privilege doesn't support query, so removing it
416 if each.get('path') == 'DEFAULT':
417 if not desired_manages_default:
418 continue
419 each.pop('query', None)
420 else:
421 desired_privilege = desired_by_path.get(each.get('path'))
422 if desired_privilege is not None and 'query' not in desired_privilege:
423 each.pop('query', None)
424 elif desired_privilege is not None and desired_privilege.get('query') is None:
425 each['query'] = None
426 elif each.get('query') in ['-', '']:
427 each['query'] = None
428 normalized_privileges.append(each)
429
430 return_record = {
431 'name': self.na_helper.safe_get(record, ['name']),
432 'privileges': normalized_privileges,
433 }
434 self.owner_uuid = self.na_helper.safe_get(record, ['owner', 'uuid'])
435 return return_record
436
437 def create_role_rest(self):
438 api = 'security/roles'
439 body = {'name': self.parameters['name']}
440 if self.parameters.get('vserver'):
441 body['owner.name'] = self.parameters['vserver']
442 privileges = []
443 for privilege in self.parameters['privileges']:
444 privilege_body = {'path': privilege['path'], 'access': privilege['access']}
445 if privilege.get('query') is not None:
446 privilege_body['query'] = privilege['query']
447 privileges.append(privilege_body)
448 body['privileges'] = privileges
449 dummy, error = rest_generic.post_async(self.rest_api, api, body, job_timeout=120)
450 if error:
451 self.module.fail_json(msg='Error creating role %s: %s' % (self.parameters['name'], to_native(error)),
452 exception=traceback.format_exc())
453
454 def delete_role_rest(self):
455 api = 'security/roles'
456 uuids = '%s/%s' % (self.owner_uuid, self.parameters['name'])
457 dummy, error = rest_generic.delete_async(self.rest_api, api, uuids, job_timeout=120)
458 if error:
459 self.module.fail_json(msg='Error deleting role %s: %s' % (self.parameters['name'], to_native(error)),
460 exception=traceback.format_exc())
461
462 def modify_role_rest(self, modify):
463 # there is no direct modify for role.
464 self.role_modified = False
465 privileges = self.get_role_privileges_rest()
466 desired_manages_default = any(
467 privilege.get('path') == 'DEFAULT' for privilege in self.parameters.get('privileges', [])
468 )
469 modify_privilege = []
470 for privilege in modify['privileges']:
471 path = privilege['path']
472 modify_privilege.append(path)
473 # if the path is not in privilege then it need to be added
474 if path not in privileges:
475 self.create_role_privilege(privilege)
476 self.role_modified = True
477 else:
478 needs_modify = False
479 # Check query changes (only for non-DEFAULT paths)
480 if privilege['path'] != 'DEFAULT' and 'query' in privilege and not privilege['path'].startswith('/api/'):
481 current_query = privileges[path].get('query')
482 desired_query = privilege.get('query')
483
484 # Normalize None, empty string, and '-' as no query
485 current_query = None if current_query in [None, '', '-'] else current_query
486 desired_query = None if desired_query in [None, '', '-'] else desired_query
487
488 needs_modify = current_query != desired_query
489
490 # Check access changes
491 if privilege.get('access') and privilege['access'] != privileges[path]['access']:
492 needs_modify = True
493
494 if needs_modify:
495 self.modify_role_privilege(privilege, path)
496 self.role_modified = True
497 for privilege_path in privileges:
498 if privilege_path == 'DEFAULT' and not desired_manages_default:
499 continue
500 if privilege_path not in modify_privilege:
501 self.delete_role_privilege(privilege_path)
502 self.role_modified = True
503
504 def get_role_privileges_rest(self):
505 api = 'security/roles/%s/%s/privileges' % (self.owner_uuid, self.parameters['name'])
506 records, error = rest_generic.get_0_or_more_records(self.rest_api, api, {})
507 if error:
508 self.module.fail_json(msg="Error getting role privileges for role %s: %s" % (self.parameters['name'], to_native(error)),
509 exception=traceback.format_exc())
510 return self.format_privileges(records)
511
512 def format_privileges(self, records):
513 return_dict = {}
514 for record in records:
515 # Normalize ONTAP's '-' query to None for consistency
516 norm_record = dict(record)
517 if norm_record.get('query') == '-':
518 norm_record['query'] = None
519 return_dict[norm_record['path']] = norm_record
520 return return_dict
521
522 def create_role_privilege(self, privilege):
523 api = 'security/roles/%s/%s/privileges' % (self.owner_uuid, self.parameters['name'])
524 body = {'path': privilege['path'], 'access': privilege['access']}
525 if privilege.get('query') is not None:
526 body['query'] = privilege['query']
527 dummy, error = rest_generic.post_async(self.rest_api, api, body, job_timeout=120)
528 if error:
529 self.module.fail_json(msg='Error creating role privilege %s: %s' % (privilege['path'], to_native(error)),
530 exception=traceback.format_exc())
531
532 def modify_role_privilege(self, privilege, path):
533 path = path.replace('/', '%2F')
534 api = 'security/roles/%s/%s/privileges' % (self.owner_uuid, self.parameters['name'])
535 body = {}
536 if privilege.get('access'):
537 body['access'] = privilege['access']
538 # DEFAULT privilege and API endpoints don't support query parameter
539 if privilege['path'] != 'DEFAULT' and not privilege['path'].startswith('/api/') and 'query' in privilege:
540 # Include query only when explicitly managed in desired state.
541 query_value = privilege.get('query')
542 body['query'] = "" if query_value in [None, '', '-'] else query_value
543 dummy, error = rest_generic.patch_async(self.rest_api, api, path, body)
544 if error:
545 self.module.fail_json(msg='Error modifying privileges for path %s: %s' % (path, to_native(error)),
546 exception=traceback.format_exc())
547
548 def delete_role_privilege(self, path):
549 path = path.replace('/', '%2F')
550 api = 'security/roles/%s/%s/privileges' % (self.owner_uuid, self.parameters['name'])
551 dummy, error = rest_generic.delete_async(self.rest_api, api, path, job_timeout=120)
552 if error:
553 # removing one of relevant commands will also remove all other commands in group.
554 # skip if entry does not exist error occurs.
555 if "entry doesn't exist" in error and "'target': 'path'" in error:
556 return
557 self.module.fail_json(msg='Error deleting role privileges %s: %s' % (self.parameters['name'], to_native(error)),
558 exception=traceback.format_exc())
559
560 def validate_create_modify_required(self, current, modify):
561 new_current = self.get_role()
562 new_cd_action = self.na_helper.get_cd_action(new_current, self.parameters)
563 new_modify = None if new_cd_action else self.na_helper.get_modified_attributes(new_current, self.parameters)
564 msg = ''
565 if current is None and new_modify:
566 msg = "Create operation also affected additional related commands: %s" % new_current['privileges']
567 elif modify and new_cd_action == 'create':
568 msg = """Create role is required, desired is: %s but it's a subset of relevant commands/command directory configured in current: %s,
569 deleting one of the commands will remove all the commands in the relevant group""" % (self.parameters['privileges'], current['privileges'])
570 elif modify and new_modify:
571 msg = "modify is required, desired: %s and new current: %s" % (self.parameters['privileges'], new_current['privileges'])
572 if msg:
573 self.module.warn(msg)
574
575 def apply(self):
576 current = self.get_role()
577 cd_action = self.na_helper.get_cd_action(current, self.parameters)
578
579 if self.parameters.get('state') == 'present':
580 # if desired state specify empty quote query and current query is None, set desired query to None.
581 # otherwise na_helper.get_modified_attributes will detect a change.
582 # for REST, query is part of a tuple in privileges list.
583 if not self.use_rest and self.parameters.get('query') == '' and current is not None and current['query'] is None:
584 self.parameters['query'] = None
585
586 # For REST, sort privileges lists before comparison to avoid false positives from different ordering
587 if self.use_rest and current and 'privileges' in current and 'privileges' in self.parameters:
588 # Sort both privilege lists by path for consistent comparison
589 current_sorted = dict(current, privileges=sorted(current['privileges'], key=itemgetter('path')))
590 params_sorted = dict(self.parameters, privileges=sorted(self.parameters['privileges'], key=itemgetter('path')))
591 modify = None if cd_action else self.na_helper.get_modified_attributes(current_sorted, params_sorted)
592 else:
593 modify = None if cd_action else self.na_helper.get_modified_attributes(current, self.parameters)
594 else:
595 modify = None if cd_action else self.na_helper.get_modified_attributes(current, self.parameters)
596 if self.na_helper.changed and not self.module.check_mode:
597 if cd_action == 'create':
598 self.create_role()
599 elif cd_action == 'delete':
600 self.delete_role()
601 elif modify:
602 self.modify_role(modify)
603 if self.use_rest:
604 if self.role_modified is False:
605 self.na_helper.changed = False
606 modify = {}
607 else:
608 self.validate_create_modify_required(current, modify)
609 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
610 self.module.exit_json(**result)
611
612
613 def main():
614 obj = NetAppOntapUserRole()
615 obj.apply()
616
617
618 if __name__ == '__main__':
619 main()