| 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() |