Debian Codegraph @

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

raw
1 #!/usr/bin/python
2
3 # (c) 2019-2025, NetApp, Inc
4 # GNU General Public License v3.0+
5 # (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
6
7 from __future__ import absolute_import, division, print_function
8 __metaclass__ = type
9
10 DOCUMENTATION = """
11
12 module: na_ontap_security_key_manager
13
14 short_description: NetApp ONTAP security key manager.
15 extends_documentation_fragment:
16 - netapp.ontap.netapp.na_ontap
17 version_added: 2.8.0
18 author: NetApp Ansible Team (@carchi8py) <[email protected]>
19
20 description:
21 - Add or delete or setup key management on NetApp ONTAP.
22 - With ZAPI, this module is limited to adding or removing external key servers. It does not manage certificates.
23 - With REST, this module can create an external key manager and certificates are required for creation.
24 - With REST, onboard key manager is supported.
25
26 options:
27
28 state:
29 description:
30 - Whether the specified key manager should exist or not.
31 choices: ['present', 'absent']
32 type: str
33 default: 'present'
34
35 ip_address:
36 description:
37 - The IP address of the external key management server.
38 - Mutually exclusive with external and onboard options.
39 - Required with ZAPI.
40 required: false
41 type: str
42
43 tcp_port:
44 description:
45 - The TCP port on which the key management server listens for incoming connections.
46 default: 5696
47 type: int
48
49 node:
50 description:
51 - The node which key management server runs on.
52 - Ignored, a warning is raised if present.
53 - Deprecated as of 21.22.0, as it was never used.
54 type: str
55
56 external:
57 description:
58 - Configures external key manager.
59 - Not supported with ZAPI.
60 - Mutually exclusive with ip_address and onboard.
61 type: dict
62 suboptions:
63 client_certificate:
64 description:
65 - Client certificate name (already installed in the cluster or SVM).
66 - Required when creating an external key manager.
67 type: str
68 server_ca_certificates:
69 description:
70 - List of server CA certificate names (already installed in the cluster or SVM).
71 - Required when creating an external key manager.
72 type: list
73 elements: str
74 servers:
75 description:
76 - List of external key servers for key management.
77 - Format - ip_address:port or FQDN:port. port defaults to the value of C(tcp_port) when not provided.
78 - The order in the list is not preserved if the key-manager already exists.
79 type: list
80 elements: str
81 version_added: 21.23.0
82
83 onboard:
84 description:
85 - Configures onboard key management.
86 - Not supported with ZAPI.
87 - Mutually exclusive with ip_address and external .
88 type: dict
89 suboptions:
90 from_passphrase:
91 description:
92 - The cluster-wide passphrase.
93 - Ignored if the onboard key manager does not already exists.
94 - Required to change the passphrase.
95 type: str
96 passphrase:
97 description:
98 - The cluster-wide passphrase.
99 type: str
100 synchronize:
101 description:
102 - Synchronizes missing onboard keys on any node in the cluster.
103 type: bool
104 default: false
105 version_added: 21.23.0
106
107 vserver:
108 description:
109 - SVM name when using an external key manager.
110 - Not supported for onboard key manager.
111 - Not supported with ZAPI.
112 type: str
113 version_added: 21.23.0
114
115 notes:
116 - Though C(node) is accepted as a parameter, it is not used in the module.
117 - Supports check_mode.
118 - Only supported at cluster level with ZAPI, or for onboard.
119 - ZAPI supports relies on deprecated APIs since ONTAP 9.6.
120 """
121
122 EXAMPLES = """
123 # Assuming module_defaults are used to set up hostname, username, password, https, validate_certs
124 - name: Delete Key Manager
125 netapp.ontap.na_ontap_security_key_manager:
126 state: absent
127
128 - name: Add Key Manager - ZAPI
129 netapp.ontap.na_ontap_security_key_manager:
130 ip_address: 0.0.0.0
131
132 - name: Add/Modify external Key Manager - REST
133 netapp.ontap.na_ontap_security_key_manager:
134 state: present
135 external:
136 servers: 10.10.10.10:5696
137 client_certificate: kmip_client
138 server_ca_certificates: kmip_ca
139 vserver: "{{ vserver | default(omit) }}"
140
141 - name: Add/Modify external Key Manager - REST
142 netapp.ontap.na_ontap_security_key_manager:
143 state: present
144 external:
145 servers: 10.10.10.10:5696,10.10.10.10:5697,10.10.10.11:5696
146 client_certificate: kmip_client
147 server_ca_certificates: kmip_ca
148 vserver: "{{ vserver | default(omit) }}"
149
150 - name: Add onboard Key Manager
151 netapp.ontap.na_ontap_security_key_manager:
152 state: present
153 onboard:
154 passphrase: "hello, le soleil brille, brille, brille!"
155
156 - name: Change passphrase for onboard Key Manager
157 netapp.ontap.na_ontap_security_key_manager:
158 state: present
159 onboard:
160 from_passphrase: "hello, le soleil brille, brille, brille!"
161 passphrase: "hello, le soleil brille, brille, brille! - 2"
162 synchronize: true
163 """
164
165 RETURN = """
166 """
167
168 import time
169 import traceback
170 from ansible.module_utils.basic import AnsibleModule
171 from ansible.module_utils._text import to_native
172 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
173 from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule
174 from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic
175
176
177 class NetAppOntapSecurityKeyManager:
178 """class with key manager operations"""
179
180 def __init__(self):
181 """Initialize module parameters"""
182 self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
183 self.argument_spec.update(
184 state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
185 ip_address=dict(required=False, type='str'),
186 node=dict(required=False, type='str'),
187 tcp_port=dict(required=False, type='int', default=5696),
188 external=dict(type='dict', options=dict(
189 client_certificate=dict(type='str'),
190 server_ca_certificates=dict(type='list', elements='str'),
191 servers=dict(type='list', elements='str'),
192 )),
193 onboard=dict(type='dict', options=dict(
194 from_passphrase=dict(type='str', no_log=True),
195 passphrase=dict(type='str', no_log=True),
196 synchronize=dict(type='bool', default=False),
197 )),
198 vserver=dict(type='str'),
199 )
200 self.module = AnsibleModule(
201 argument_spec=self.argument_spec,
202 mutually_exclusive=[
203 ('external', 'onboard'),
204 ('ip_address', 'onboard'),
205 ('ip_address', 'external'),
206 ('onboard', 'vserver'),
207 ],
208 supports_check_mode=True
209 )
210 self.na_helper = NetAppModule()
211 self.parameters = self.na_helper.set_parameters(self.module.params)
212 if 'node' in self.parameters:
213 self.module.warn('The option "node" is deprecated and should not be used.')
214 self.rest_api = netapp_utils.OntapRestAPI(self.module)
215 self.use_rest = self.rest_api.is_rest()
216
217 if self.use_rest:
218 self.rest_api.fail_if_not_rest_minimum_version('na_ontap_security_key_manager', 9, 7)
219 self.uuid = None
220 self.scope, self.resource = self.set_scope(self.parameters.get('vserver'))
221 # expand parameters to match REST returned info
222 self.update_parameters_rest()
223 else:
224 rest_only = [x for x in ('external', 'onboard', 'vserver') if x in self.parameters]
225 if rest_only:
226 self.module.fail_json(msg='Error: REST is required for %s option%s.'
227 % (', '.join(rest_only), 's' if len(rest_only) > 1 else ''))
228 if 'ip_address' not in self.parameters:
229 self.module.fail_json(msg='missing required arguments: ip_address')
230 if not netapp_utils.has_netapp_lib():
231 self.module.fail_json(msg=netapp_utils.netapp_lib_is_required())
232 self.cluster = netapp_utils.setup_na_ontap_zapi(module=self.module)
233
234 def add_port(self, server):
235 """ ONTAP automatically adds :5696 when the port is not present
236 We need to add it to make the module idempotent
237 """
238 return server if ':' in server else '%s:%s' % (server, self.parameters['tcp_port'])
239
240 def update_parameters_rest(self):
241 """ expand parameters to match REST returned info
242 transform legacy input
243 """
244 if self.scope == 'svm':
245 self.parameters['svm'] = {'name': self.parameters.pop('vserver')}
246 servers = self.na_helper.safe_get(self.parameters, ['external', 'servers'])
247 if servers:
248 # eliminate any empty entry and add port when needed
249 self.parameters['external']['servers'] = [{'server': self.add_port(server)} for server in servers if server]
250
251 ip_address = self.parameters.pop('ip_address', None)
252 if ip_address:
253 ip_address += ':%s' % self.parameters.pop('tcp_port')
254 self.parameters['external'] = {'servers': [{'server': ip_address}]}
255
256 @staticmethod
257 def set_scope(vserver):
258 """ define the scope, and a user friendly resource name"""
259 return (
260 'cluster' if vserver is None else 'svm',
261 'cluster' if vserver is None else 'vserver: %s' % vserver
262 )
263
264 def get_key_manager(self):
265 """
266 get key manager by ip address.
267 :return: a dict of key manager
268 """
269 if self.use_rest:
270 return self.get_key_manager_rest()
271 key_manager_info = netapp_utils.zapi.NaElement('security-key-manager-get-iter')
272 query_details = netapp_utils.zapi.NaElement.create_node_with_children(
273 'key-manager-info', **{'key-manager-ip-address': self.parameters['ip_address']})
274 query = netapp_utils.zapi.NaElement('query')
275 query.add_child_elem(query_details)
276 key_manager_info.add_child_elem(query)
277
278 try:
279 result = self.cluster.invoke_successfully(key_manager_info, enable_tunneling=False)
280 except netapp_utils.zapi.NaApiError as error:
281 self.module.fail_json(msg='Error fetching key manager: %s' % to_native(error),
282 exception=traceback.format_exc())
283
284 return_value = None
285 if result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) > 0:
286 key_manager = result.get_child_by_name('attributes-list').get_child_by_name('key-manager-info')
287 return_value = {}
288 if key_manager.get_child_by_name('key-manager-ip-address'):
289 return_value['ip_address'] = key_manager.get_child_content('key-manager-ip-address')
290 if key_manager.get_child_by_name('key-manager-server-status'):
291 return_value['server_status'] = key_manager.get_child_content('key-manager-server-status')
292 if key_manager.get_child_by_name('key-manager-tcp-port'):
293 return_value['tcp_port'] = int(key_manager.get_child_content('key-manager-tcp-port'))
294
295 return return_value
296
297 def key_manager_setup(self):
298 """
299 set up external key manager.
300 deprecated as of ONTAP 9.6.
301 """
302 key_manager_setup = netapp_utils.zapi.NaElement('security-key-manager-setup')
303 # if specify on-boarding passphrase, it is on-boarding key management.
304 # it not, then it's external key management.
305 try:
306 self.cluster.invoke_successfully(key_manager_setup, True)
307 except netapp_utils.zapi.NaApiError as error:
308 self.module.fail_json(msg='Error setting up key manager: %s' % to_native(error),
309 exception=traceback.format_exc())
310
311 def create_key_manager(self):
312 """
313 add key manager.
314 """
315 if self.use_rest:
316 return self.create_key_manager_rest()
317 key_manager_create = netapp_utils.zapi.NaElement('security-key-manager-add')
318 key_manager_create.add_new_child('key-manager-ip-address', self.parameters['ip_address'])
319 if self.parameters.get('tcp_port'):
320 key_manager_create.add_new_child('key-manager-tcp-port', str(self.parameters['tcp_port']))
321 try:
322 self.cluster.invoke_successfully(key_manager_create, True)
323 except netapp_utils.zapi.NaApiError as error:
324 self.module.fail_json(msg='Error creating key manager: %s' % to_native(error),
325 exception=traceback.format_exc())
326
327 def delete_key_manager(self):
328 """
329 delete key manager.
330 """
331 if self.use_rest:
332 return self.delete_key_manager_rest()
333 key_manager_delete = netapp_utils.zapi.NaElement('security-key-manager-delete')
334 key_manager_delete.add_new_child('key-manager-ip-address', self.parameters['ip_address'])
335 try:
336 self.cluster.invoke_successfully(key_manager_delete, True)
337 except netapp_utils.zapi.NaApiError as error:
338 self.module.fail_json(msg='Error deleting key manager: %s' % to_native(error),
339 exception=traceback.format_exc())
340
341 def _get_security_certificate_uuid_rest_any(self, query, fields):
342 api = 'security/certificates'
343 query['scope'] = self.scope
344 if self.scope == 'svm':
345 # try first at SVM level
346 query['svm.name'] = self.parameters['svm']['name']
347 record, error = rest_generic.get_one_record(self.rest_api, api, query, fields)
348 if record and error is None:
349 return record, error
350 # retry at cluster scope
351 del query['svm.name']
352 query['scope'] = 'cluster'
353 return rest_generic.get_one_record(self.rest_api, api, query, fields)
354
355 def get_security_certificate_uuid_rest_97(self, name, type):
356 query = {'common_name': name, 'type': type}
357 fields = 'uuid,common_name,type'
358 return self._get_security_certificate_uuid_rest_any(query, fields)
359
360 def get_security_certificate_uuid_rest_98(self, name):
361 query = {'name': name}
362 fields = 'uuid,name,common_name,type'
363 return self._get_security_certificate_uuid_rest_any(query, fields)
364
365 def get_security_certificate_uuid_rest(self, name, type):
366 if self.rest_api.meets_rest_minimum_version(self.use_rest, 9, 8):
367 record, error = self.get_security_certificate_uuid_rest_98(name)
368 message = 'certificate %s not found, retrying with common_name and type %s.'\
369 % (name, type)
370 else:
371 record, error = None, None
372 message = 'name is not supported in 9.6 or 9.7, using common_name %s and type %s.'\
373 % (name, type)
374 if not error and not record:
375 self.module.warn(message)
376 record, error = self.get_security_certificate_uuid_rest_97(name, type)
377 if not error and not record:
378 error = 'not found'
379 if error:
380 self.module.fail_json(msg='Error fetching security certificate info for %s of type: %s on %s: %s.' % (name, type, self.resource, error))
381 return record['uuid']
382
383 def get_key_manager_rest(self):
384 api = 'security/key-managers'
385 query = {'scope': self.scope}
386 fields = 'status,external,uuid,onboard'
387 if self.scope == 'svm':
388 query['svm.name'] = self.parameters['svm']['name']
389 record, error = rest_generic.get_one_record(self.rest_api, api, query, fields)
390 if error:
391 if self.scope == 'svm' and 'SVM "%s" does not exist' % self.parameters['svm']['name'] in error:
392 return None
393 self.module.fail_json(msg='Error fetching key manager info for %s: %s' % (self.resource, error))
394 if record:
395 self.uuid = record['uuid']
396 if 'external' in record and (self.na_helper.safe_get(record, ['onboard', 'enabled']) is False):
397 del record['onboard']
398 if 'external' in record and 'servers' in record['external']:
399 # remove extra fields that are readonly and not relevant for modify
400 record['external']['servers'] = [{'server': server['server']} for server in record['external']['servers']]
401 self.na_helper.remove_hal_links(record)
402
403 return record
404
405 def create_body(self, params):
406 if 'external' in params:
407 body = {'external': self.na_helper.filter_out_none_entries(params['external'])}
408 elif 'onboard' in params:
409 body = {'onboard': self.na_helper.filter_out_none_entries(params['onboard'])}
410 body['onboard'].pop('from_passphrase', None)
411 else:
412 return
413 if 'svm' in self.parameters:
414 body['svm'] = self.na_helper.filter_out_none_entries(self.parameters['svm'])
415 return body
416
417 def create_key_manager_rest(self, retrying=None):
418 api = 'security/key-managers'
419 body = self.create_body(self.parameters)
420 dummy, error = rest_generic.post_async(self.rest_api, api, body)
421 if error:
422 # ONTAP returns no record if external manager is configured but no server is present
423 if not retrying and ('already has external key management configured' in error
424 or 'External key management already configured' in error):
425 self.module.warn("deleting and recreating key manager as no key server is configured.")
426 self.delete_key_manager_rest()
427 time.sleep(5)
428 return self.create_key_manager_rest('retrying')
429 resource = 'cluster' if self.parameters.get('vserver') is None else self.parameters['vserver']
430 self.module.fail_json(msg='Error creating key manager for %s: %s' % (resource, error))
431
432 def modify_key_manager_rest(self, modify, current=None, return_error=False):
433 # external key servers cannot be updated in PATCH, they are handled later
434 key_servers = self.na_helper.safe_get(modify, ['external', 'servers'])
435 if key_servers:
436 del modify['external']['servers']
437 if not modify['external']:
438 del modify['external']
439 if modify:
440 api = 'security/key-managers'
441 body = self.create_body(modify)
442 dummy, error = rest_generic.patch_async(self.rest_api, api, self.uuid, body)
443 if error:
444 if return_error:
445 return error
446 resource = 'cluster' if self.parameters.get('vserver') is None else self.parameters['vserver']
447 self.module.fail_json(msg='Error modifying key manager for %s: %s' % (resource, error))
448 if key_servers:
449 self.update_key_server_list(current)
450 return None
451
452 def check_passphrase_rest(self, passphrase):
453 """ API does not return the passphrase
454 In order to check for idempotency, check if the desired passphrase is already active"""
455 params = {
456 'onboard': {
457 'existing_passphrase': passphrase,
458 'passphrase': passphrase,
459 }
460 }
461 error = self.modify_key_manager_rest(params, return_error=True)
462 if not error:
463 return 'unexpected_success in check_passphrase_rest', error
464 if 'Cluster-wide passphrase is incorrect.' in error:
465 return 'incorrect_passphrase', error
466 if 'New passphrase cannot be same as the old passphrase.' in error or \
467 'The new passphrase is same as old passphrase.' in error:
468 return 'current_passphrase', error
469 self.module.warn('Unexpected response in check_passphrase_rest: %s' % error)
470 return 'unexpected_error in check_passphrase_rest', error
471
472 def delete_key_manager_rest(self):
473 api = 'security/key-managers'
474 if self.uuid is None:
475 # ONTAP does not return a record when an external key manager is configured without any external server
476 query = {'scope': self.scope}
477 if self.scope == 'svm':
478 query['svm.name'] = self.parameters['svm']['name']
479 else:
480 query = None
481 dummy, error = rest_generic.delete_async(self.rest_api, api, self.uuid, query)
482 if error:
483 resource = 'cluster' if self.parameters.get('vserver') is None else self.parameters['vserver']
484 self.module.fail_json(msg='Error deleting key manager for %s: %s' % (resource, error))
485
486 def validate_delete_action(self, current):
487 return
488
489 def validate_modify(self, current, modify):
490 error = None if self.use_rest else 'modify is not supported with ZAPI, new values: %s, current values: %s' % (modify, current)
491 if error:
492 self.module.fail_json(msg='Error, cannot modify existing configuraton: %s' % error)
493
494 def substitute_certificate_uuids(self, params):
495 if 'external' not in params:
496 return
497 certificate = self.na_helper.safe_get(params, ['external', 'client_certificate'])
498 if certificate:
499 params['external']['client_certificate'] = {'uuid': self.get_security_certificate_uuid_rest(certificate, 'client')}
500 certificates = self.na_helper.safe_get(params, ['external', 'server_ca_certificates'])
501 if certificates:
502 params['external']['server_ca_certificates'] = [{'uuid': self.get_security_certificate_uuid_rest(certificate, 'server_ca')}
503 for certificate in certificates]
504
505 def is_passphrase_update_required(self, passphrase, from_passphrase):
506 check_new, __ = self.check_passphrase_rest(passphrase)
507 if check_new == 'current_passphrase':
508 return False
509 check_old, error = self.check_passphrase_rest(from_passphrase)
510 if check_old == 'incorrect_passphrase' and check_new == 'incorrect_passphrase':
511 self.module.fail_json(msg='Error: neither from_passphrase nor passphrase match installed passphrase: %s' % error)
512 # if check_old is current, we're good to change the passphrase. For other errors, we'll just try again, we already warned.
513 return True
514
515 def force_onboard_actions(self):
516 """ synchronize and passphrase are not returned in GET so we need to be creative """
517 if 'onboard' not in self.parameters:
518 return None, None
519 passphrase = self.na_helper.safe_get(self.parameters, ['onboard', 'passphrase'])
520 # do we need to synchronize
521 modify_sync = None
522 if self.na_helper.safe_get(self.parameters, ['onboard', 'synchronize']):
523 if passphrase is None:
524 self.module.fail_json(msg='Error: passphrase is required for synchronize.')
525 modify_sync = {'onboard': {
526 'synchronize': True,
527 'existing_passphrase': passphrase
528 }}
529 # do we need to update the passphrase
530 modify_passphrase = None
531 from_passphrase = self.na_helper.safe_get(self.parameters, ['onboard', 'from_passphrase'])
532 if passphrase and not from_passphrase:
533 check_new, __ = self.check_passphrase_rest(passphrase)
534 if check_new == 'current_passphrase':
535 self.module.warn('Passphrase was not changed: The new passphrase is same as old passphrase.')
536 else:
537 self.module.warn('Passphrase was ignored as existing_passphrase was not given.')
538 if not passphrase and from_passphrase and not modify_sync:
539 self.module.warn('from_passphrase is ignored')
540 if passphrase and from_passphrase and self.is_passphrase_update_required(passphrase, from_passphrase):
541 modify_passphrase = {'onboard': {
542 'passphrase': passphrase,
543 'existing_passphrase': from_passphrase
544 }}
545 # wrapping up
546 if modify_passphrase or modify_sync:
547 self.na_helper.changed = True
548 return modify_passphrase, modify_sync
549
550 def validate_type_change(self, current):
551 """present moving from onboard to external and reciprocally"""
552 error = None
553 if 'onboard' in current and 'external' in self.parameters:
554 error = 'onboard key-manager is already installed, it needs to be deleted first.'
555 if 'external' in current and 'onboard' in self.parameters:
556 error = 'external key-manager is already installed, it needs to be deleted first.'
557 if error:
558 self.module.fail_json(msg='Error, cannot modify existing configuraton: %s' % error)
559
560 def local_get_modified_attributes(self, current):
561 modify = self.na_helper.get_modified_attributes(current, self.parameters)
562 if current and 'external' in self.parameters and not self.na_helper.safe_get(modify, ['external', 'servers']):
563 current_servers = self.na_helper.safe_get(current, ['external', 'servers'])
564 desired_servers = self.na_helper.safe_get(self.parameters, ['external', 'servers'])
565 # order matters for key servers
566 if current_servers != desired_servers:
567 if 'external' not in modify:
568 modify['external'] = {}
569 modify['external']['servers'] = desired_servers
570 self.na_helper.changed = True
571 return modify
572
573 def add_external_server_rest(self, server):
574 api = 'security/key-managers/%s/key-servers' % self.uuid
575 body = {
576 'server': server
577 }
578 dummy, error = rest_generic.post_async(self.rest_api, api, body)
579 if error:
580 self.module.fail_json(msg='Error adding external key server %s: %s' % (server, error))
581
582 def remove_external_server_rest(self, server):
583 api = 'security/key-managers/%s/key-servers' % self.uuid
584 dummy, error = rest_generic.delete_async(self.rest_api, api, server)
585 if error:
586 self.module.fail_json(msg='Error removing external key server %s: %s' % (server, error))
587
588 def update_key_server_list(self, current):
589 desired_servers = self.na_helper.safe_get(self.parameters, ['external', 'servers'])
590 if desired_servers is None:
591 return
592 desired_servers = [server['server'] for server in desired_servers]
593 current_servers = self.na_helper.safe_get(current, ['external', 'servers']) or []
594 current_servers = [server['server'] for server in current_servers]
595 for server in current_servers:
596 if server not in desired_servers:
597 self.remove_external_server_rest(server)
598 for server in desired_servers:
599 if server not in current_servers:
600 self.add_external_server_rest(server)
601
602 def apply(self):
603 if not self.use_rest:
604 self.key_manager_setup()
605 current = self.get_key_manager()
606 if current:
607 self.validate_type_change(current)
608 if self.parameters['state'] == 'present':
609 self.substitute_certificate_uuids(self.parameters)
610 cd_action = self.na_helper.get_cd_action(current, self.parameters)
611 modify = self.local_get_modified_attributes(current) if cd_action is None else None
612 # with onboard, changing a passphrase or synchronizing cannot be done in the same PATCH request
613 modify_passphrase, modify_sync = self.force_onboard_actions() if cd_action is None and current else (None, None)
614 if cd_action == 'delete' and self.use_rest:
615 self.validate_delete_action(current)
616 if modify:
617 self.validate_modify(current, modify)
618 if self.na_helper.changed and not self.module.check_mode:
619 if cd_action == 'create':
620 self.create_key_manager()
621 elif cd_action == 'delete':
622 self.delete_key_manager()
623 elif modify:
624 self.modify_key_manager_rest(modify, current)
625 elif modify_passphrase:
626 self.modify_key_manager_rest(modify_passphrase)
627 elif modify_sync:
628 self.modify_key_manager_rest(modify_sync)
629 result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify)
630 self.module.exit_json(**result)
631
632
633 def main():
634 """Apply volume operations from playbook"""
635 obj = NetAppOntapSecurityKeyManager()
636 obj.apply()
637
638
639 if __name__ == '__main__':
640 main()