Debian Codegraph @

ansible_collections/netapp/ontap/plugins/modules/na_ontap_fpolicy_ext_engine.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
8 __metaclass__ = type
9
10 DOCUMENTATION = '''
11 module: na_ontap_fpolicy_ext_engine
12 short_description: NetApp ONTAP fPolicy external engine configuration.
13 extends_documentation_fragment:
14 - netapp.ontap.netapp.na_ontap
15 version_added: '21.4.0'
16 author: NetApp Ansible Team (@carchi8py) <[email protected]>
17
18 description:
19 - Create, delete or modify fpolicy external engine.
20 options:
21 state:
22 description:
23 - Whether the fPolicy external engine is present or not
24 choices: ['present', 'absent']
25 default: present
26 type: str
27
28 vserver:
29 description:
30 - the name of the vserver to create the external engine on
31 required: true
32 type: str
33
34 name:
35 description:
36 - Name of the external engine.
37 required: true
38 type: str
39
40 certificate_ca:
41 description:
42 - Certificate authority name. No default value is set for this field.
43 type: str
44
45 certificate_common_name:
46 description:
47 - FQDN or custom common name of certificate. No default value is set for this field.
48 type: str
49
50 certificate_serial:
51 description:
52 - Serial number of certificate. No default value is set for this field.
53 type: str
54
55 extern_engine_type:
56 description:
57 - External engine type. If the engine is asynchronous, no reply is sent from FPolicy servers. Default value set for this field is synchronous.
58 choices: ['synchronous', 'asynchronous']
59 type: str
60
61 is_resiliency_enabled:
62 description:
63 - Indicates if the resiliency with this engine is required.
64 - If set to true, the notifications will be stored in a path as resiliency_directory_path
65 - If it is false, the notifications will not be stored. Default value is false.
66 type: bool
67
68 max_connection_retries:
69 description:
70 - Number of times storage appliance will attempt to establish a broken connection to FPolicy server. Default value set for this field is 5.
71 type: int
72
73 max_server_reqs:
74 description:
75 - Maximum number of outstanding screen requests that will be queued for an FPolicy Server. Default value set for this field is 50.
76 type: int
77
78 port:
79 description:
80 - Port number of the FPolicy server application.
81 type: int
82
83 primary_servers:
84 description:
85 - Primary FPolicy servers.
86 type: list
87 elements: str
88
89 recv_buffer_size:
90 description:
91 - Receive buffer size of connected socket for FPolicy Server. Default value set for this field is 256 kilobytes (256Kb).
92 type: int
93
94 resiliency_directory_path:
95 description:
96 - Directory path under Vserver for storing file access notifications. File access notifications will be stored in a generated file during the outage time.
97 - The path is the full, user visible path relative to the Vserver root, and it might be crossing junction mount points.
98 type: str
99
100 secondary_servers:
101 description:
102 - Secondary FPolicy servers. No default value is set for this field.
103 type: list
104 elements: str
105
106 send_buffer_size:
107 description:
108 - Send buffer size of connected socket for FPolicy Server. Default value set for this field is 256 kilobytes (256Kb).
109 type: int
110
111 ssl_option:
112 description:
113 - SSL option for external communication. No default value is set for this field
114 choices: ['no_auth', 'server_auth', 'mutual_auth']
115 type: str
116
117 '''
118
119 EXAMPLES = """
120 - name: Create fPolicy external engine
121 netapp.ontap.na_ontap_fpolicy_ext_engine:
122 state: present
123 vserver: svm1
124 name: fpolicy_ext_engine
125 port: 8787
126 extern_engine_type: asynchronous
127 primary_servers: ['10.11.12.13', '10.11.12.14']
128 ssl_option: no_auth
129 username: "{{ netapp_username }}"
130 password: "{{ netapp_password }}"
131 hostname: "{{ netapp_hostname }}"
132
133 - name: Modify fPolicy external engine
134 netapp.ontap.na_ontap_fpolicy_ext_engine:
135 state: present
136 vserver: svm1
137 name: fpolicy_ext_engine
138 port: 7878
139 extern_engine_type: synchronous
140 primary_servers: ['10.11.12.15', '10.11.12.16']
141 ssl_option: server_auth
142 username: "{{ netapp_username }}"
143 password: "{{ netapp_password }}"
144 hostname: "{{ netapp_hostname }}"
145
146 - name: Delete fPolicy external engine
147 netapp.ontap.na_ontap_fpolicy_ext_engine:
148 state: absent
149 vserver: svm1
150 name: fpolicy_engine
151 username: "{{ netapp_username }}"
152 password: "{{ netapp_password }}"
153 hostname: "{{ netapp_hostname }}"
154 """
155
156 RETURN = """
157 """
158
159 import traceback
160
161 from ansible.module_utils.basic import AnsibleModule
162 from ansible.module_utils._text import to_native
163 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
164 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
165 from ansible_collections.netapp.ontap.plugins.module_utils.netapp import OntapRestAPI
166 import ansible_collections.netapp.ontap.plugins.module_utils.rest_response_helpers as rrh
167
168
169 class NetAppOntapFpolicyExtEngine():
170
171 def __init__(self):
172 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
173 self.argument_spec.update(dict(
174 state=dict(choices=['present', 'absent'], default='present'),
175 vserver=dict(required=True, type='str'),
176 name=dict(required=True, type='str'),
177 certificate_ca=dict(required=False, type='str'),
178 certificate_common_name=dict(required=False, type='str'),
179 certificate_serial=dict(required=False, type='str'),
180 extern_engine_type=dict(required=False, type='str', choices=['synchronous', 'asynchronous']),
181 is_resiliency_enabled=dict(required=False, type='bool'),
182 max_connection_retries=dict(required=False, type='int'),
183 max_server_reqs=dict(required=False, type='int'),
184 port=dict(required=False, type='int'),
185 primary_servers=dict(required=False, type='list', elements='str'),
186 recv_buffer_size=dict(required=False, type='int'),
187 resiliency_directory_path=dict(required=False, type='str'),
188 secondary_servers=dict(required=False, type='list', elements='str'),
189 send_buffer_size=dict(required=False, type='int'),
190 ssl_option=dict(required=False, type='str', choices=['no_auth', 'server_auth', 'mutual_auth']),
191 ))
192 self.module = AnsibleModule(
193 argument_spec=self.argument_spec,
194 required_if=[('state', 'present', ['ssl_option', 'primary_servers', 'port'])],
195 supports_check_mode=True
196 )
197
198 self.na_helper = NetAppModule()
199 self.parameters = self.na_helper.set_parameters(self.module.params)
200
201 self.rest_api = OntapRestAPI(self.module)
202 self.use_rest = self.rest_api.is_rest()
203
204 if not self.use_rest:
205 if not netapp_utils.has_netapp_lib():
206 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
207 else:
208 self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver'])
209
210 def create_rest_body(self):
211 """
212 Create an fPolicy body for a create operation
213 :return: body as dict
214 """
215
216 body = {
217 'vserver': self.parameters['vserver'],
218 'engine-name': self.parameters['name'],
219 'primary_servers': self.parameters['primary_servers'],
220 'port': self.parameters['port'],
221 'ssl_option': self.parameters['ssl_option']
222 }
223
224 list_of_options = ['secondary_servers', 'is_resiliency_enabled', 'resiliency_directory_path',
225 'max_connection_retries', 'max_server_reqs', 'recv_buffer_size', 'send_buffer_size',
226 'certificate_ca', 'certificate_common_name', 'certificate_serial', 'extern_engine_type']
227
228 for option in list_of_options:
229 if option in self.parameters:
230 body[option] = self.parameters[option]
231
232 return body
233
234 def create_zapi_api(self, api):
235 """
236 Create an the ZAPI API request for fpolicy modify and create
237 :return: ZAPI API object
238 """
239 fpolicy_ext_engine_obj = netapp_utils.zapi.NaElement(api)
240 fpolicy_ext_engine_obj.add_new_child('engine-name', self.parameters['name'])
241 fpolicy_ext_engine_obj.add_new_child('port-number', self.na_helper.get_value_for_int(from_zapi=False, value=self.parameters['port']))
242 fpolicy_ext_engine_obj.add_new_child('ssl-option', self.parameters['ssl_option'])
243
244 primary_servers_obj = netapp_utils.zapi.NaElement('primary-servers')
245
246 for primary_server in self.parameters['primary_servers']:
247 primary_servers_obj.add_new_child('ip-address', primary_server)
248 fpolicy_ext_engine_obj.add_child_elem(primary_servers_obj)
249
250 if 'secondary_servers' in self.parameters:
251 secondary_servers_obj = netapp_utils.zapi.NaElement('secondary-servers')
252
253 for secondary_server in self.parameters['secondary_servers']:
254 primary_servers_obj.add_new_child('ip-address', secondary_server)
255 fpolicy_ext_engine_obj.add_child_elem(secondary_servers_obj)
256
257 if 'is_resiliency_enabled' in self.parameters:
258 fpolicy_ext_engine_obj.add_new_child(
259 'is-resiliency-enabled',
260 self.na_helper.get_value_for_bool(from_zapi=False, value=self.parameters['is_resiliency_enabled'])
261 )
262 if 'resiliency_directory_path' in self.parameters:
263 fpolicy_ext_engine_obj.add_new_child('resiliency-directory-path', self.parameters['resiliency_directory_path'])
264 if 'max_connection_retries' in self.parameters:
265 fpolicy_ext_engine_obj.add_new_child(
266 'max-connection-retries',
267 self.na_helper.get_value_for_int(from_zapi=False, value=self.parameters['max_connection_retries'])
268 )
269 if 'max_server_reqs' in self.parameters:
270 fpolicy_ext_engine_obj.add_new_child(
271 'max-server-requests',
272 self.na_helper.get_value_for_int(from_zapi=False, value=self.parameters['max_server_reqs'])
273 )
274 if 'recv_buffer_size' in self.parameters:
275 fpolicy_ext_engine_obj.add_new_child(
276 'recv-buffer-size',
277 self.na_helper.get_value_for_int(from_zapi=False, value=self.parameters['recv_buffer_size'])
278 )
279 if 'send_buffer_size' in self.parameters:
280 fpolicy_ext_engine_obj.add_new_child(
281 'send-buffer-size',
282 self.na_helper.get_value_for_int(from_zapi=False, value=self.parameters['send_buffer_size'])
283 )
284 if 'certificate_ca' in self.parameters:
285 fpolicy_ext_engine_obj.add_new_child('certificate-ca', self.parameters['certificate_ca'])
286 if 'certificate_common_name' in self.parameters:
287 fpolicy_ext_engine_obj.add_new_child('certificate-common-name', self.parameters['certificate_common_name'])
288 if 'certificate_serial' in self.parameters:
289 fpolicy_ext_engine_obj.add_new_child('certificate-serial', self.parameters['certificate_serial'])
290 if 'extern_engine_type' in self.parameters:
291 fpolicy_ext_engine_obj.add_new_child('extern-engine-type', self.parameters['extern_engine_type'])
292
293 return fpolicy_ext_engine_obj
294
295 def create_fpolicy_ext_engine(self):
296 """
297 Create an fPolicy external engine
298 :return: nothing
299 """
300
301 if self.use_rest:
302 api = "/private/cli/vserver/fpolicy/policy/external-engine"
303 body = self.create_rest_body()
304
305 dummy, error = self.rest_api.post(api, body)
306 if error:
307 self.module.fail_json(msg=error)
308 else:
309 fpolicy_ext_engine_obj = self.create_zapi_api('fpolicy-policy-external-engine-create')
310
311 try:
312 self.server.invoke_successfully(fpolicy_ext_engine_obj, True)
313 except netapp_utils.zapi.NaApiError as error:
314 self.module.fail_json(
315 msg='Error creating fPolicy external engine %s on vserver %s: %s' %
316 (self.parameters['name'], self.parameters['vserver'], to_native(error)), exception=traceback.format_exc()
317 )
318
319 def modify_fpolicy_ext_engine(self, modify):
320 """
321 Modify an fPolicy external engine
322 :return: nothing
323 """
324
325 if self.use_rest:
326 api = "/private/cli/vserver/fpolicy/policy/external-engine"
327 query = {
328 'vserver': self.parameters['vserver'],
329 'engine-name': self.parameters['name']
330 }
331
332 dummy, error = self.rest_api.patch(api, modify, query)
333 if error:
334 self.module.fail_json(msg=error)
335 else:
336 fpolicy_ext_engine_obj = self.create_zapi_api('fpolicy-policy-external-engine-modify')
337
338 try:
339 self.server.invoke_successfully(fpolicy_ext_engine_obj, True)
340 except netapp_utils.zapi.NaApiError as error:
341 self.module.fail_json(
342 msg='Error modifying fPolicy external engine %s on vserver %s: %s' %
343 (self.parameters['name'], self.parameters['vserver'], to_native(error)), exception=traceback.format_exc()
344 )
345
346 def delete_fpolicy_ext_engine(self):
347 """
348 Delete an fPolicy external engine
349 :return: nothing
350 """
351
352 if self.use_rest:
353 api = "/private/cli/vserver/fpolicy/policy/external-engine"
354 query = {
355 'vserver': self.parameters['vserver'],
356 'engine-name': self.parameters['name']
357 }
358
359 dummy, error = self.rest_api.delete(api, query)
360
361 if error:
362 self.module.fail_json(msg=error)
363 else:
364
365 fpolicy_ext_engine_obj = netapp_utils.zapi.NaElement('fpolicy-policy-external-engine-delete')
366 fpolicy_ext_engine_obj.add_new_child('engine-name', self.parameters['name'])
367
368 try:
369 self.server.invoke_successfully(fpolicy_ext_engine_obj, True)
370 except netapp_utils.zapi.NaApiError as error:
371 self.module.fail_json(
372 msg='Error deleting fPolicy external engine %s on vserver %s: %s' %
373 (self.parameters['name'], self.parameters['vserver'], to_native(error)), exception=traceback.format_exc()
374 )
375
376 def get_fpolicy_ext_engine(self):
377 """
378 Check to see if the fPolicy external engine exists or not
379 :return: dict of engine properties if exist, None if not
380 """
381 return_value = None
382
383 if self.use_rest:
384 fields = [
385 "vserver",
386 "engine-name",
387 "primary-servers",
388 "port",
389 "secondary-servers",
390 "extern-engine-type",
391 "ssl-option",
392 "max-connection-retries",
393 "max-server-reqs",
394 "certificate-common-name",
395 "certificate-serial",
396 "certificate-ca",
397 "recv-buffer-size",
398 "send-buffer-size",
399 "is-resiliency-enabled",
400 "resiliency-directory-path"
401 ]
402
403 api = "private/cli/vserver/fpolicy/policy/external-engine"
404 query = {
405 'fields': ','.join(fields),
406 'engine-name': self.parameters['name'],
407 'vserver': self.parameters['vserver']
408 }
409 message, error = self.rest_api.get(api, query)
410
411 return_info, error = rrh.check_for_0_or_1_records(api, message, error)
412 if return_info is None:
413 return None
414
415 return_value = message['records'][0]
416 return return_value
417 else:
418
419 fpolicy_ext_engine_obj = netapp_utils.zapi.NaElement('fpolicy-policy-external-engine-get-iter')
420 fpolicy_ext_engine_config = netapp_utils.zapi.NaElement('fpolicy-external-engine-info')
421 fpolicy_ext_engine_config.add_new_child('engine-name', self.parameters['name'])
422 fpolicy_ext_engine_config.add_new_child('vserver', self.parameters['vserver'])
423 query = netapp_utils.zapi.NaElement('query')
424 query.add_child_elem(fpolicy_ext_engine_config)
425 fpolicy_ext_engine_obj.add_child_elem(query)
426
427 try:
428 result = self.server.invoke_successfully(fpolicy_ext_engine_obj, True)
429 except netapp_utils.zapi.NaApiError as error:
430 self.module.fail_json(
431 msg='Error searching for fPolicy engine %s on vserver %s: %s' %
432 (self.parameters['name'], self.parameters['vserver'], to_native(error)), exception=traceback.format_exc()
433 )
434
435 if result.get_child_by_name('attributes-list'):
436 fpolicy_ext_engine_attributes = result['attributes-list']['fpolicy-external-engine-info']
437
438 primary_servers = []
439 primary_servers_elem = fpolicy_ext_engine_attributes.get_child_by_name('primary-servers')
440 for primary_server in primary_servers_elem.get_children():
441 primary_servers.append(primary_server.get_content())
442
443 secondary_servers = []
444 if fpolicy_ext_engine_attributes.get_child_by_name('secondary-servers'):
445 secondary_servers_elem = fpolicy_ext_engine_attributes.get_child_by_name('secondary-servers')
446
447 for secondary_server in secondary_servers_elem.get_children():
448 secondary_servers.append(secondary_server.get_content())
449
450 return_value = {
451 'vserver': fpolicy_ext_engine_attributes.get_child_content('vserver'),
452 'name': fpolicy_ext_engine_attributes.get_child_content('engine-name'),
453 'certificate_ca': fpolicy_ext_engine_attributes.get_child_content('certificate-ca'),
454 'certificate_common_name': fpolicy_ext_engine_attributes.get_child_content('certificate-common-name'),
455 'certificate_serial': fpolicy_ext_engine_attributes.get_child_content('certificate-serial'),
456 'extern_engine_type': fpolicy_ext_engine_attributes.get_child_content('extern-engine-type'),
457 'is_resiliency_enabled': self.na_helper.get_value_for_bool(
458 from_zapi=True,
459 value=fpolicy_ext_engine_attributes.get_child_content('is-resiliency-enabled')
460 ),
461 'max_connection_retries': self.na_helper.get_value_for_int(
462 from_zapi=True,
463 value=fpolicy_ext_engine_attributes.get_child_content('max-connection-retries')
464 ),
465 'max_server_reqs': self.na_helper.get_value_for_int(
466 from_zapi=True,
467 value=fpolicy_ext_engine_attributes.get_child_content('max-server-requests')
468 ),
469 'port': self.na_helper.get_value_for_int(
470 from_zapi=True,
471 value=fpolicy_ext_engine_attributes.get_child_content('port-number')
472 ),
473 'primary_servers': primary_servers,
474 'secondary_servers': secondary_servers,
475 'recv_buffer_size': self.na_helper.get_value_for_int(
476 from_zapi=True,
477 value=fpolicy_ext_engine_attributes.get_child_content('recv-buffer-size')
478 ),
479 'resiliency_directory_path': fpolicy_ext_engine_attributes.get_child_content('resiliency-directory-path'),
480 'send_buffer_size': self.na_helper.get_value_for_int(
481 from_zapi=True,
482 value=fpolicy_ext_engine_attributes.get_child_content('send-buffer-size')
483 ),
484 'ssl_option': fpolicy_ext_engine_attributes.get_child_content('ssl-option'),
485 }
486
487 return return_value
488
489 def apply(self):
490 current, modify = self.get_fpolicy_ext_engine(), None
491
492 cd_action = self.na_helper.get_cd_action(current, self.parameters)
493
494 if cd_action is None and self.parameters['state'] == 'present':
495 modify = self.na_helper.get_modified_attributes(current, self.parameters)
496
497 if self.na_helper.changed:
498 if not self.module.check_mode:
499 if cd_action == 'create':
500 self.create_fpolicy_ext_engine()
501 elif cd_action == 'delete':
502 self.delete_fpolicy_ext_engine()
503 elif modify:
504 self.modify_fpolicy_ext_engine(modify)
505 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
506 self.module.exit_json(**result)
507
508
509 def main():
510 """
511 Execute action from playbook
512 """
513 command = NetAppOntapFpolicyExtEngine()
514 command.apply()
515
516
517 if __name__ == '__main__':
518 main()