Debian Codegraph @

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

raw
1 #!/usr/bin/python
2
3 # (c) 2021-2025, 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 ANSIBLE_METADATA = {'metadata_version': '1.1',
10 'status': ['preview'],
11 'supported_by': 'community'}
12
13 DOCUMENTATION = '''
14 module: na_ontap_fpolicy_policy
15 short_description: NetApp ONTAP - Create, delete or modify an FPolicy policy.
16 extends_documentation_fragment:
17 - netapp.ontap.netapp.na_ontap
18 version_added: '21.3.0'
19 author: NetApp Ansible Team (@carchi8py) <[email protected]>
20 description:
21 - Create, delete or modify an FPolicy policy. Fpolicy scope must exist before running this module.
22 - FPolicy is a file access notification framework that enables an administrator to monitor file and directory access in storage configured for CIFS and NFS.
23 options:
24 state:
25 description:
26 - Whether the fPolicy policy should exist or not
27 choices: ['present', 'absent']
28 type: str
29 default: present
30
31 vserver:
32 description:
33 - the name of the vserver to create the policy on
34 type: str
35 required: True
36
37 name:
38 description:
39 - Name of the policy.
40 type: str
41 required: True
42
43 allow_privileged_access:
44 description:
45 - Specifies if privileged access should be given to FPolicy servers registered for the policy.
46 type: bool
47
48 engine:
49 description:
50 - Name of the Engine. External engines must be created prior to running this task.
51 type: str
52
53 events:
54 description:
55 - Events for file access monitoring.
56 type: list
57 elements: str
58 required: True
59
60 is_mandatory:
61 description:
62 - Specifies the action to take on a file access event in the case when all primary and secondary servers are down or no response is received from the
63 - FPolicy servers within a given timeout period. When True, file access events will be denied under these circumstances
64 type: bool
65
66 is_passthrough_read_enabled:
67 description:
68 - Specifies if passthrough-read should be allowed to FPolicy servers registered for the policy.
69 type: bool
70
71 privileged_user_name:
72 description:
73 - User name for privileged access.
74 type: str
75
76 '''
77
78 EXAMPLES = """
79 - name: Create FPolicy policy
80 netapp.ontap.na_ontap_fpolicy_policy:
81 state: present
82 vserver: svm1
83 name: fpolicy_policy
84 events: fcpolicy_event
85 engine: fpolicy_ext_engine
86 username: "{{ netapp_username }}"
87 password: "{{ netapp_password }}"
88 hostname: "{{ netapp_hostname }}"
89
90 - name: Modify FPolicy policy
91 netapp.ontap.na_ontap_fpolicy_policy:
92 state: present
93 vserver: svm1
94 name: fpolicy_policy
95 events: fcpolicy_event
96 is_mandatory: false
97 username: "{{ netapp_username }}"
98 password: "{{ netapp_password }}"
99 hostname: "{{ netapp_hostname }}"
100
101 - name: Delete FPolicy policy
102 netapp.ontap.na_ontap_fpolicy_policy:
103 state: absent
104 vserver: svm1
105 name: fpolicy_policy
106 events: fcpolicy_event
107 username: "{{ netapp_username }}"
108 password: "{{ netapp_password }}"
109 hostname: "{{ netapp_hostname }}"
110 """
111
112 RETURN = """
113 """
114
115 import traceback
116
117 from ansible.module_utils.basic import AnsibleModule
118 from ansible.module_utils._text import to_native
119 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
120 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
121 from ansible_collections.netapp.ontap.plugins.module_utils.netapp import OntapRestAPI
122
123
124 class NetAppOntapFpolicyPolicy():
125
126 def __init__(self):
127 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
128 self.argument_spec.update(dict(
129 state=dict(choices=['present', 'absent'], default='present'),
130 vserver=dict(required=True, type='str'),
131 name=dict(required=True, type='str'),
132 allow_privileged_access=dict(required=False, type='bool'),
133 engine=dict(required=False, type='str'),
134 events=dict(required=True, type='list', elements='str'),
135 is_mandatory=dict(required=False, type='bool'),
136 is_passthrough_read_enabled=dict(required=False, type='bool'),
137 privileged_user_name=dict(required=False, type='str')
138 ))
139 self.module = AnsibleModule(
140 argument_spec=self.argument_spec,
141 supports_check_mode=True
142 )
143
144 self.na_helper = NetAppModule()
145 self.parameters = self.na_helper.set_parameters(self.module.params)
146
147 self.rest_api = OntapRestAPI(self.module)
148 self.use_rest = self.rest_api.is_rest()
149
150 if not self.use_rest:
151 if not netapp_utils.has_netapp_lib():
152 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
153 else:
154 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
155
156 def get_fpolicy_policy(self):
157 """
158 Check if FPolicy policy exists, if it exists get the current state of the policy.
159 """
160 if self.use_rest:
161 api = "/private/cli/vserver/fpolicy/policy"
162 query = {
163 'vserver': self.parameters['vserver'],
164 'policy-name': self.parameters['name'],
165 'fields': 'events,engine,allow-privileged-access,is-mandatory,is-passthrough-read-enabled,privileged-user-name'
166 }
167
168 message, error = self.rest_api.get(api, query)
169 if error:
170 self.module.fail_json(msg=error)
171 if len(message.keys()) == 0:
172 return None
173 if 'records' in message and len(message['records']) == 0:
174 return None
175 if 'records' not in message:
176 error = "Unexpected response in get_fpolicy_policy from %s: %s" % (api, repr(message))
177 self.module.fail_json(msg=error)
178 return_value = {
179 'vserver': message['records'][0]['vserver'],
180 'name': message['records'][0]['policy_name'],
181 'events': message['records'][0]['events'],
182 'engine': message['records'][0]['engine'],
183 'is_mandatory': message['records'][0]['is_mandatory'],
184 'is_passthrough_read_enabled': message['records'][0]['is_passthrough_read_enabled']
185 }
186 allow_privileged_access = True if message['records'][0]['allow_privileged_access'] == 'yes' else False
187 return_value['allow_privileged_access'] = allow_privileged_access
188 if 'privileged_user_name' in message['records'][0]:
189 return_value['privileged_user_name'] = message['records'][0]['privileged_user_name']
190
191 return return_value
192
193 else:
194 return_value = None
195
196 fpolicy_policy_obj = netapp_utils.zapi.NaElement('fpolicy-policy-get-iter')
197 fpolicy_policy_config = netapp_utils.zapi.NaElement('fpolicy-policy-info')
198 fpolicy_policy_config.add_new_child('policy-name', self.parameters['name'])
199 fpolicy_policy_config.add_new_child('vserver', self.parameters['vserver'])
200 query = netapp_utils.zapi.NaElement('query')
201 query.add_child_elem(fpolicy_policy_config)
202 fpolicy_policy_obj.add_child_elem(query)
203
204 try:
205 result = self.server.invoke_successfully(fpolicy_policy_obj, True)
206
207 except netapp_utils.zapi.NaApiError as error:
208 self.module.fail_json(
209 msg='Error searching for fPolicy policy %s on vserver %s: %s' % (self.parameters['name'], self.parameters['vserver'], to_native(error)),
210 exception=traceback.format_exc())
211 if result.get_child_by_name('attributes-list'):
212 fpolicy_policy_attributes = result['attributes-list']['fpolicy-policy-info']
213 events = []
214 if fpolicy_policy_attributes.get_child_by_name('events'):
215 for event in fpolicy_policy_attributes.get_child_by_name('events').get_children():
216 events.append(event.get_content())
217
218 return_value = {
219 'vserver': fpolicy_policy_attributes.get_child_content('vserver'),
220 'name': fpolicy_policy_attributes.get_child_content('policy-name'),
221 'events': events,
222 'allow_privileged_access': self.na_helper.get_value_for_bool(
223 from_zapi=True, value=fpolicy_policy_attributes.get_child_content('allow-privileged-access')),
224 'engine': fpolicy_policy_attributes.get_child_content('engine-name'),
225 'is_mandatory': self.na_helper.get_value_for_bool(
226 from_zapi=True, value=fpolicy_policy_attributes.get_child_content('is-mandatory')),
227 'is_passthrough_read_enabled': self.na_helper.get_value_for_bool(
228 from_zapi=True, value=fpolicy_policy_attributes.get_child_content('is-passthrough-read-enabled')),
229 'privileged_user_name': fpolicy_policy_attributes.get_child_content('privileged-user-name')
230 }
231
232 return return_value
233
234 def create_fpolicy_policy(self):
235 """
236 Create an FPolicy policy.
237 """
238 if self.use_rest:
239 api = "/private/cli/vserver/fpolicy/policy"
240 body = {
241 'vserver': self.parameters['vserver'],
242 'policy-name': self.parameters['name'],
243 'events': self.parameters['events']
244 }
245 for parameter in ('engine', 'allow_privileged_access', 'is_mandatory', 'is_passthrough_read_enabled', 'privileged_user_name'):
246 if parameter in self.parameters:
247 body[parameter.replace('_', '-')] = self.parameters[parameter]
248
249 dummy, error = self.rest_api.post(api, body)
250 if error:
251 self.module.fail_json(msg=error)
252
253 else:
254 fpolicy_policy_obj = netapp_utils.zapi.NaElement('fpolicy-policy-create')
255 fpolicy_policy_obj.add_new_child('policy-name', self.parameters['name'])
256 if 'is_mandatory' in self.parameters:
257 fpolicy_policy_obj.add_new_child('is-mandatory', self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['is_mandatory']))
258 if 'engine' in self.parameters:
259 fpolicy_policy_obj.add_new_child('engine-name', self.parameters['engine'])
260 if 'allow_privileged_access' in self.parameters:
261 fpolicy_policy_obj.add_new_child(
262 'allow-privileged-access', self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['allow_privileged_access'])
263 )
264 if 'is_passthrough_read_enabled' in self.parameters:
265 fpolicy_policy_obj.add_new_child(
266 'is-passthrough-read-enabled', self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['is_passthrough_read_enabled'])
267 )
268 events_obj = netapp_utils.zapi.NaElement('events')
269 for event in self.parameters['events']:
270 events_obj.add_new_child('event-name', event)
271 fpolicy_policy_obj.add_child_elem(events_obj)
272
273 if 'privileged_user_name' in self.parameters:
274 fpolicy_policy_obj.add_new_child('privileged-user-name', self.parameters['privileged_user_name'])
275 try:
276 self.server.invoke_successfully(fpolicy_policy_obj, True)
277 except netapp_utils.zapi.NaApiError as error:
278 self.module.fail_json(
279 msg='Error creating fPolicy policy %s on vserver %s: %s' % (self.parameters['name'], self.parameters['vserver'], to_native(error)),
280 exception=traceback.format_exc()
281 )
282
283 def modify_fpolicy_policy(self, modify):
284 """
285 Modify an FPolicy policy.
286 """
287 if self.use_rest:
288 api = "/private/cli/vserver/fpolicy/policy"
289 query = {'vserver': self.parameters['vserver']}
290 query['policy-name'] = self.parameters['name']
291 dummy, error = self.rest_api.patch(api, modify, query)
292 if error:
293 self.module.fail_json(msg=error)
294 else:
295 fpolicy_policy_obj = netapp_utils.zapi.NaElement('fpolicy-policy-modify')
296 fpolicy_policy_obj.add_new_child('policy-name', self.parameters['name'])
297 if 'is_mandatory' in self.parameters:
298 fpolicy_policy_obj.add_new_child('is-mandatory', self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['is_mandatory']))
299 if 'engine' in self.parameters:
300 fpolicy_policy_obj.add_new_child('engine-name', self.parameters['engine'])
301 if 'allow_privileged_access' in self.parameters:
302 fpolicy_policy_obj.add_new_child(
303 'allow-privileged-access', self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['allow_privileged_access'])
304 )
305 if 'is_passthrough_read_enabled' in self.parameters:
306 fpolicy_policy_obj.add_new_child(
307 'is-passthrough-read-enabled', self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['is_passthrough_read_enabled'])
308 )
309 events_obj = netapp_utils.zapi.NaElement('events')
310 for event in self.parameters['events']:
311 events_obj.add_new_child('event-name', event)
312 fpolicy_policy_obj.add_child_elem(events_obj)
313
314 if 'privileged_user_name' in self.parameters:
315 fpolicy_policy_obj.add_new_child('privileged-user-name', self.parameters['privileged_user_name'])
316 try:
317 self.server.invoke_successfully(fpolicy_policy_obj, True)
318 except netapp_utils.zapi.NaApiError as error:
319 self.module.fail_json(
320 msg='Error modifying fPolicy policy %s on vserver %s: %s' %
321 (self.parameters['name'], self.parameters['vserver'], to_native(error)), exception=traceback.format_exc()
322 )
323
324 def delete_fpolicy_policy(self):
325 """
326 Delete an FPolicy policy.
327 """
328 if self.use_rest:
329 api = "/private/cli/vserver/fpolicy/policy"
330 body = {
331 'vserver': self.parameters['vserver'],
332 'policy-name': self.parameters['name']
333 }
334 dummy, error = self.rest_api.delete(api, body)
335 if error:
336 self.module.fail_json(msg=error)
337
338 else:
339 fpolicy_policy_obj = netapp_utils.zapi.NaElement('fpolicy-policy-delete')
340 fpolicy_policy_obj.add_new_child('policy-name', self.parameters['name'])
341
342 try:
343 self.server.invoke_successfully(fpolicy_policy_obj, True)
344 except netapp_utils.zapi.NaApiError as error:
345 self.module.fail_json(
346 msg='Error deleting fPolicy policy %s on vserver %s: %s' %
347 (self.parameters['name'], self.parameters['vserver'], to_native(error)), exception=traceback.format_exc()
348 )
349
350 def apply(self):
351 current = self.get_fpolicy_policy()
352 modify = None
353 cd_action = self.na_helper.get_cd_action(current, self.parameters)
354 if cd_action is None and self.parameters['state'] == 'present':
355 modify = self.na_helper.get_modified_attributes(current, self.parameters)
356 if self.na_helper.changed:
357 if not self.module.check_mode:
358 if cd_action == 'create':
359 self.create_fpolicy_policy()
360 elif cd_action == 'delete':
361 self.delete_fpolicy_policy()
362 elif modify:
363 self.modify_fpolicy_policy(modify)
364 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
365 self.module.exit_json(**result)
366
367
368 def main():
369 """
370 Execute action from playbook
371 """
372 command = NetAppOntapFpolicyPolicy()
373 command.apply()
374
375
376 if __name__ == '__main__':
377 main()