| 1 |
#!/usr/bin/python |
| 2 |
''' |
| 3 |
(c) 2019, Red Hat, Inc |
| 4 |
(c) 2019-2025, NetApp, Inc |
| 5 |
GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) |
| 6 |
''' |
| 7 |
|
| 8 |
from __future__ import absolute_import, division, print_function |
| 9 |
__metaclass__ = type |
| 10 |
|
| 11 |
DOCUMENTATION = ''' |
| 12 |
|
| 13 |
module: na_ontap_kerberos_realm |
| 14 |
|
| 15 |
short_description: NetApp ONTAP vserver nfs kerberos realm |
| 16 |
extends_documentation_fragment: |
| 17 |
- netapp.ontap.netapp.na_ontap |
| 18 |
version_added: 2.9.0 |
| 19 |
author: Milan Zink (@zeten30) <[email protected]>,<[email protected]> |
| 20 |
|
| 21 |
description: |
| 22 |
- Create, modify or delete vserver kerberos realm configuration |
| 23 |
|
| 24 |
options: |
| 25 |
|
| 26 |
state: |
| 27 |
description: |
| 28 |
- Whether the Kerberos realm is present or absent. |
| 29 |
choices: ['present', 'absent'] |
| 30 |
default: 'present' |
| 31 |
type: str |
| 32 |
|
| 33 |
vserver: |
| 34 |
description: |
| 35 |
- vserver/svm with kerberos realm configured |
| 36 |
required: true |
| 37 |
type: str |
| 38 |
|
| 39 |
realm: |
| 40 |
description: |
| 41 |
- Kerberos realm name |
| 42 |
required: true |
| 43 |
type: str |
| 44 |
|
| 45 |
kdc_vendor: |
| 46 |
description: |
| 47 |
- The vendor of the Key Distribution Centre (KDC) server |
| 48 |
- Required if I(state=present) |
| 49 |
choices: ['other', 'microsoft'] |
| 50 |
type: str |
| 51 |
|
| 52 |
kdc_ip: |
| 53 |
description: |
| 54 |
- IP address of the Key Distribution Centre (KDC) server |
| 55 |
- Required if I(state=present) |
| 56 |
type: str |
| 57 |
|
| 58 |
kdc_port: |
| 59 |
description: |
| 60 |
- TCP port on the KDC to be used for Kerberos communication. |
| 61 |
- The default for this parameter is 88. |
| 62 |
type: int |
| 63 |
|
| 64 |
clock_skew: |
| 65 |
description: |
| 66 |
- The clock skew in minutes is the tolerance for accepting tickets with time stamps that do not exactly match the host's system clock. |
| 67 |
- The default for this parameter is '5' minutes. |
| 68 |
- Supported from ONTAP 9.13.1 in REST. |
| 69 |
type: str |
| 70 |
|
| 71 |
comment: |
| 72 |
description: |
| 73 |
- Optional comment |
| 74 |
type: str |
| 75 |
|
| 76 |
admin_server_ip: |
| 77 |
description: |
| 78 |
- IP address of the host where the Kerberos administration daemon is running. This is usually the master KDC. |
| 79 |
- If this parameter is omitted, the address specified in kdc_ip is used. |
| 80 |
- Supported from ONTAP 9.13.1 in REST. |
| 81 |
type: str |
| 82 |
|
| 83 |
admin_server_port: |
| 84 |
description: |
| 85 |
- The TCP port on the Kerberos administration server where the Kerberos administration service is running. |
| 86 |
- The default for this parmater is '749'. |
| 87 |
- Supported from ONTAP 9.13.1 in REST. |
| 88 |
type: str |
| 89 |
|
| 90 |
pw_server_ip: |
| 91 |
description: |
| 92 |
- IP address of the host where the Kerberos password-changing server is running. |
| 93 |
- Typically, this is the same as the host indicated in the adminserver-ip. |
| 94 |
- If this parameter is omitted, the IP address in kdc-ip is used. |
| 95 |
- Supported from ONTAP 9.13.1 in REST. |
| 96 |
type: str |
| 97 |
|
| 98 |
pw_server_port: |
| 99 |
description: |
| 100 |
- The TCP port on the Kerberos password-changing server where the Kerberos password-changing service is running. |
| 101 |
- The default for this parameter is '464'. |
| 102 |
- Supported from ONTAP 9.13.1 in REST. |
| 103 |
type: str |
| 104 |
|
| 105 |
ad_server_ip: |
| 106 |
description: |
| 107 |
- IP Address of the Active Directory Domain Controller (DC). This is a mandatory parameter if the kdc-vendor is 'microsoft'. |
| 108 |
type: str |
| 109 |
version_added: '20.4.0' |
| 110 |
|
| 111 |
ad_server_name: |
| 112 |
description: |
| 113 |
- Host name of the Active Directory Domain Controller (DC). This is a mandatory parameter if the kdc-vendor is 'microsoft'. |
| 114 |
type: str |
| 115 |
version_added: '20.4.0' |
| 116 |
|
| 117 |
notes: |
| 118 |
- supports ZAPI and REST. REST requires ONTAP 9.6 or later. |
| 119 |
- supports check mode. |
| 120 |
''' |
| 121 |
|
| 122 |
EXAMPLES = ''' |
| 123 |
- name: Create kerberos realm other kdc vendor |
| 124 |
netapp.ontap.na_ontap_kerberos_realm: |
| 125 |
state: present |
| 126 |
realm: 'EXAMPLE.COM' |
| 127 |
vserver: 'vserver1' |
| 128 |
kdc_ip: '1.2.3.4' |
| 129 |
kdc_vendor: 'other' |
| 130 |
hostname: "{{ netapp_hostname }}" |
| 131 |
username: "{{ netapp_username }}" |
| 132 |
password: "{{ netapp_password }}" |
| 133 |
|
| 134 |
- name: Create kerberos realm Microsoft kdc vendor |
| 135 |
netapp.ontap.na_ontap_kerberos_realm: |
| 136 |
state: present |
| 137 |
realm: 'EXAMPLE.COM' |
| 138 |
vserver: 'vserver1' |
| 139 |
kdc_ip: '1.2.3.4' |
| 140 |
kdc_vendor: 'microsoft' |
| 141 |
ad_server_ip: '0.0.0.0' |
| 142 |
ad_server_name: 'server' |
| 143 |
hostname: "{{ netapp_hostname }}" |
| 144 |
username: "{{ netapp_username }}" |
| 145 |
password: "{{ netapp_password }}" |
| 146 |
|
| 147 |
- name: Create kerberos realm other kdc vendor - REST |
| 148 |
netapp.ontap.na_ontap_kerberos_realm: |
| 149 |
state: present |
| 150 |
realm: 'EXAMPLE.COM' |
| 151 |
vserver: 'vserver1' |
| 152 |
kdc_ip: '1.2.3.4' |
| 153 |
kdc_vendor: 'other' |
| 154 |
pw_server_ip: '0.0.0.0' |
| 155 |
pw_server_port: '5' |
| 156 |
admin_server_ip: '1.2.3.4' |
| 157 |
admin_server_port: '2' |
| 158 |
hostname: "{{ netapp_hostname }}" |
| 159 |
username: "{{ netapp_username }}" |
| 160 |
password: "{{ netapp_password }}" |
| 161 |
''' |
| 162 |
|
| 163 |
RETURN = ''' |
| 164 |
''' |
| 165 |
|
| 166 |
import traceback |
| 167 |
import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils |
| 168 |
from ansible_collections.netapp.ontap.plugins.module_utils.netapp_module import NetAppModule |
| 169 |
from ansible.module_utils._text import to_native |
| 170 |
from ansible.module_utils.basic import AnsibleModule |
| 171 |
from ansible_collections.netapp.ontap.plugins.module_utils import rest_generic |
| 172 |
|
| 173 |
|
| 174 |
class NetAppOntapKerberosRealm: |
| 175 |
''' |
| 176 |
Kerberos Realm definition class |
| 177 |
''' |
| 178 |
|
| 179 |
def __init__(self): |
| 180 |
self.argument_spec = netapp_utils.na_ontap_host_argument_spec() |
| 181 |
self.argument_spec.update(dict( |
| 182 |
admin_server_ip=dict(required=False, type='str'), |
| 183 |
admin_server_port=dict(required=False, type='str'), |
| 184 |
clock_skew=dict(required=False, type='str'), |
| 185 |
comment=dict(required=False, type='str'), |
| 186 |
kdc_ip=dict(required=False, type='str'), |
| 187 |
kdc_port=dict(required=False, type='int'), |
| 188 |
kdc_vendor=dict(required=False, type='str', |
| 189 |
choices=['microsoft', 'other']), |
| 190 |
pw_server_ip=dict(required=False, type='str'), |
| 191 |
pw_server_port=dict(required=False, type='str'), |
| 192 |
realm=dict(required=True, type='str'), |
| 193 |
state=dict(required=False, choices=['present', 'absent'], default='present'), |
| 194 |
vserver=dict(required=True, type='str'), |
| 195 |
ad_server_ip=dict(required=False, type='str'), |
| 196 |
ad_server_name=dict(required=False, type='str') |
| 197 |
)) |
| 198 |
|
| 199 |
self.module = AnsibleModule( |
| 200 |
argument_spec=self.argument_spec, |
| 201 |
supports_check_mode=True, |
| 202 |
required_if=[ |
| 203 |
('state', 'present', ['kdc_vendor', 'kdc_ip']), |
| 204 |
('kdc_vendor', 'microsoft', ['ad_server_ip', 'ad_server_name']) |
| 205 |
] |
| 206 |
) |
| 207 |
self.na_helper = NetAppModule() |
| 208 |
self.parameters = self.na_helper.set_parameters(self.module.params) |
| 209 |
# Set up Rest API |
| 210 |
self.rest_api = netapp_utils.OntapRestAPI(self.module) |
| 211 |
partially_supported_rest_properties = [['admin_server_ip', (9, 13, 1)], ['admin_server_port', (9, 13, 1)], ['clock_skew', (9, 13, 1)], |
| 212 |
['pw_server_ip', (9, 13, 1)], ['pw_server_port', (9, 13, 1)]] |
| 213 |
self.use_rest = self.rest_api.is_rest_supported_properties(self.parameters, None, partially_supported_rest_properties) |
| 214 |
self.svm_uuid = None |
| 215 |
|
| 216 |
if not self.use_rest: |
| 217 |
if not netapp_utils.has_netapp_lib(): |
| 218 |
self.module.fail_json(msg=netapp_utils.netapp_lib_is_required()) |
| 219 |
self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.parameters['vserver']) |
| 220 |
|
| 221 |
self.simple_attributes = [ |
| 222 |
'admin_server_ip', |
| 223 |
'admin_server_port', |
| 224 |
'clock_skew', |
| 225 |
'kdc_ip', |
| 226 |
'kdc_vendor', |
| 227 |
] |
| 228 |
|
| 229 |
def get_krbrealm(self): |
| 230 |
''' |
| 231 |
Checks if Kerberos Realm config exists. |
| 232 |
|
| 233 |
:return: |
| 234 |
kerberos realm object if found |
| 235 |
None if not found |
| 236 |
:rtype: object/None |
| 237 |
''' |
| 238 |
if self.use_rest: |
| 239 |
return self.get_krbrealm_rest() |
| 240 |
|
| 241 |
# Make query |
| 242 |
krbrealm_info = netapp_utils.zapi.NaElement('kerberos-realm-get-iter') |
| 243 |
query_details = netapp_utils.zapi.NaElement.create_node_with_children('kerberos-realm', **{'realm': self.parameters['realm'], |
| 244 |
'vserver-name': self.parameters['vserver']}) |
| 245 |
query = netapp_utils.zapi.NaElement('query') |
| 246 |
query.add_child_elem(query_details) |
| 247 |
krbrealm_info.add_child_elem(query) |
| 248 |
|
| 249 |
try: |
| 250 |
result = self.server.invoke_successfully(krbrealm_info, enable_tunneling=True) |
| 251 |
except netapp_utils.zapi.NaApiError as error: |
| 252 |
self.module.fail_json(msg='Error fetching kerberos realm %s: %s' % (self.parameters['realm'], to_native(error))) |
| 253 |
|
| 254 |
# Get Kerberos Realm details |
| 255 |
krbrealm_details = None |
| 256 |
if (result.get_child_by_name('num-records') and int(result.get_child_content('num-records')) >= 1): |
| 257 |
attributes_list = result.get_child_by_name('attributes-list') |
| 258 |
config_info = attributes_list.get_child_by_name('kerberos-realm') |
| 259 |
|
| 260 |
krbrealm_details = { |
| 261 |
'admin_server_ip': config_info.get_child_content('admin-server-ip'), |
| 262 |
'admin_server_port': config_info.get_child_content('admin-server-port'), |
| 263 |
'clock_skew': config_info.get_child_content('clock-skew'), |
| 264 |
'kdc_ip': config_info.get_child_content('kdc-ip'), |
| 265 |
'kdc_port': int(config_info.get_child_content('kdc-port')), |
| 266 |
'kdc_vendor': config_info.get_child_content('kdc-vendor'), |
| 267 |
'pw_server_ip': config_info.get_child_content('password-server-ip'), |
| 268 |
'pw_server_port': config_info.get_child_content('password-server-port'), |
| 269 |
'realm': config_info.get_child_content('realm'), |
| 270 |
'vserver': config_info.get_child_content('vserver-name'), |
| 271 |
'ad_server_ip': config_info.get_child_content('ad-server-ip'), |
| 272 |
'ad_server_name': config_info.get_child_content('ad-server-name'), |
| 273 |
'comment': config_info.get_child_content('comment') |
| 274 |
} |
| 275 |
|
| 276 |
return krbrealm_details |
| 277 |
|
| 278 |
def create_krbrealm(self): |
| 279 |
'''supported |
| 280 |
Create Kerberos Realm configuration |
| 281 |
''' |
| 282 |
if self.use_rest: |
| 283 |
return self.create_krbrealm_rest() |
| 284 |
|
| 285 |
options = { |
| 286 |
'realm': self.parameters['realm'] |
| 287 |
} |
| 288 |
|
| 289 |
# Other options/attributes |
| 290 |
for attribute in self.simple_attributes: |
| 291 |
if self.parameters.get(attribute) is not None: |
| 292 |
options[str(attribute).replace('_', '-')] = self.parameters[attribute] |
| 293 |
|
| 294 |
if self.parameters.get('kdc_port'): |
| 295 |
options['kdc-port'] = str(self.parameters['kdc_port']) |
| 296 |
if self.parameters.get('pw_server_ip') is not None: |
| 297 |
options['password-server-ip'] = self.parameters['pw_server_ip'] |
| 298 |
if self.parameters.get('pw_server_port') is not None: |
| 299 |
options['password-server-port'] = self.parameters['pw_server_port'] |
| 300 |
|
| 301 |
if self.parameters.get('ad_server_ip') is not None: |
| 302 |
options['ad-server-ip'] = self.parameters['ad_server_ip'] |
| 303 |
if self.parameters.get('ad_server_name') is not None: |
| 304 |
options['ad-server-name'] = self.parameters['ad_server_name'] |
| 305 |
|
| 306 |
# Initialize NaElement |
| 307 |
krbrealm_create = netapp_utils.zapi.NaElement.create_node_with_children('kerberos-realm-create', **options) |
| 308 |
|
| 309 |
# Try to create Kerberos Realm configuration |
| 310 |
try: |
| 311 |
self.server.invoke_successfully(krbrealm_create, enable_tunneling=True) |
| 312 |
except netapp_utils.zapi.NaApiError as errcatch: |
| 313 |
self.module.fail_json(msg='Error creating Kerberos Realm configuration %s: %s' % (self.parameters['realm'], to_native(errcatch)), |
| 314 |
exception=traceback.format_exc()) |
| 315 |
|
| 316 |
def delete_krbrealm(self): |
| 317 |
''' |
| 318 |
Delete Kerberos Realm configuration |
| 319 |
''' |
| 320 |
if self.use_rest: |
| 321 |
return self.delete_krbrealm_rest() |
| 322 |
krbrealm_delete = netapp_utils.zapi.NaElement.create_node_with_children('kerberos-realm-delete', **{'realm': self.parameters['realm']}) |
| 323 |
try: |
| 324 |
self.server.invoke_successfully(krbrealm_delete, enable_tunneling=True) |
| 325 |
except netapp_utils.zapi.NaApiError as errcatch: |
| 326 |
self.module.fail_json(msg='Error deleting Kerberos Realm configuration %s: %s' % ( |
| 327 |
self.parameters['realm'], to_native(errcatch)), exception=traceback.format_exc()) |
| 328 |
|
| 329 |
def modify_krbrealm(self, modify): |
| 330 |
''' |
| 331 |
Modify Kerberos Realm |
| 332 |
:param modify: list of modify attributes |
| 333 |
''' |
| 334 |
if self.use_rest: |
| 335 |
return self.modify_krbrealm_rest(modify) |
| 336 |
krbrealm_modify = netapp_utils.zapi.NaElement('kerberos-realm-modify') |
| 337 |
krbrealm_modify.add_new_child('realm', self.parameters['realm']) |
| 338 |
|
| 339 |
for attribute in modify: |
| 340 |
if attribute in self.simple_attributes: |
| 341 |
krbrealm_modify.add_new_child(str(attribute).replace('_', '-'), self.parameters[attribute]) |
| 342 |
if attribute == 'kdc_port': |
| 343 |
krbrealm_modify.add_new_child('kdc-port', str(self.parameters['kdc_port'])) |
| 344 |
if attribute == 'pw_server_ip': |
| 345 |
krbrealm_modify.add_new_child('password-server-ip', self.parameters['pw_server_ip']) |
| 346 |
if attribute == 'pw_server_port': |
| 347 |
krbrealm_modify.add_new_child('password-server-port', self.parameters['pw_server_port']) |
| 348 |
if attribute == 'ad_server_ip': |
| 349 |
krbrealm_modify.add_new_child('ad-server-ip', self.parameters['ad_server_ip']) |
| 350 |
if attribute == 'ad_server_name': |
| 351 |
krbrealm_modify.add_new_child('ad-server-name', self.parameters['ad_server_name']) |
| 352 |
if attribute == 'comment': |
| 353 |
krbrealm_modify.add_new_child('comment', self.parameters['comment']) |
| 354 |
|
| 355 |
# Try to modify Kerberos Realm |
| 356 |
try: |
| 357 |
self.server.invoke_successfully(krbrealm_modify, enable_tunneling=True) |
| 358 |
except netapp_utils.zapi.NaApiError as errcatch: |
| 359 |
self.module.fail_json(msg='Error modifying Kerberos Realm %s: %s' % (self.parameters['realm'], to_native(errcatch)), |
| 360 |
exception=traceback.format_exc()) |
| 361 |
|
| 362 |
def get_krbrealm_rest(self): |
| 363 |
api = 'protocols/nfs/kerberos/realms' |
| 364 |
params = { |
| 365 |
'name': self.parameters['realm'], |
| 366 |
'svm.name': self.parameters['vserver'], |
| 367 |
'fields': 'kdc,ad_server,svm,comment,password_server,admin_server,clock_skew' |
| 368 |
} |
| 369 |
record, error = rest_generic.get_one_record(self.rest_api, api, params) |
| 370 |
if error: |
| 371 |
self.module.fail_json(msg='Error fetching kerberos realm %s: %s' % (self.parameters['realm'], to_native(error))) |
| 372 |
if record: |
| 373 |
self.svm_uuid = record['svm']['uuid'] |
| 374 |
return { |
| 375 |
'kdc_ip': self.na_helper.safe_get(record, ['kdc', 'ip']), |
| 376 |
'kdc_port': self.na_helper.safe_get(record, ['kdc', 'port']), |
| 377 |
'kdc_vendor': self.na_helper.safe_get(record, ['kdc', 'vendor']), |
| 378 |
'ad_server_ip': self.na_helper.safe_get(record, ['ad_server', 'address']), |
| 379 |
'ad_server_name': self.na_helper.safe_get(record, ['ad_server', 'name']), |
| 380 |
'comment': self.na_helper.safe_get(record, ['comment']), |
| 381 |
'pw_server_ip': self.na_helper.safe_get(record, ['password_server', 'address']), |
| 382 |
'pw_server_port': str(self.na_helper.safe_get(record, ['password_server', 'port'])), |
| 383 |
'admin_server_ip': self.na_helper.safe_get(record, ['admin_server', 'address']), |
| 384 |
'admin_server_port': str(self.na_helper.safe_get(record, ['admin_server', 'port'])), |
| 385 |
'clock_skew': str(self.na_helper.safe_get(record, ['clock_skew'])) |
| 386 |
} |
| 387 |
return None |
| 388 |
|
| 389 |
def create_krbrealm_rest(self): |
| 390 |
api = 'protocols/nfs/kerberos/realms' |
| 391 |
body = { |
| 392 |
'name': self.parameters['realm'], |
| 393 |
'svm.name': self.parameters['vserver'], |
| 394 |
'kdc.ip': self.parameters['kdc_ip'], |
| 395 |
'kdc.vendor': self.parameters['kdc_vendor'] |
| 396 |
} |
| 397 |
if self.parameters.get('kdc_port'): |
| 398 |
body['kdc.port'] = self.parameters['kdc_port'] |
| 399 |
if self.parameters.get('comment'): |
| 400 |
body['comment'] = self.parameters['comment'] |
| 401 |
if self.parameters.get('ad_server_ip'): |
| 402 |
body['ad_server.address'] = self.parameters['ad_server_ip'] |
| 403 |
if self.parameters.get('ad_server_name'): |
| 404 |
body['ad_server.name'] = self.parameters['ad_server_name'] |
| 405 |
if self.parameters.get('admin_server_port'): |
| 406 |
body['admin_server.port'] = self.parameters['admin_server_port'] |
| 407 |
if self.parameters.get('pw_server_port'): |
| 408 |
body['password_server.port'] = self.parameters['pw_server_port'] |
| 409 |
if self.parameters.get('clock_skew'): |
| 410 |
body['clock_skew'] = self.parameters['clock_skew'] |
| 411 |
if self.parameters.get('admin_server_ip'): |
| 412 |
body['admin_server.address'] = self.parameters['admin_server_ip'] |
| 413 |
if self.parameters.get('pw_server_ip'): |
| 414 |
body['password_server.address'] = self.parameters['pw_server_ip'] |
| 415 |
dummy, error = rest_generic.post_async(self.rest_api, api, body) |
| 416 |
if error: |
| 417 |
self.module.fail_json(msg='Error creating Kerberos Realm configuration %s: %s' % (self.parameters['realm'], to_native(error))) |
| 418 |
|
| 419 |
def modify_krbrealm_rest(self, modify): |
| 420 |
api = 'protocols/nfs/kerberos/realms/%s' % self.svm_uuid |
| 421 |
body = {} |
| 422 |
if modify.get('kdc_ip'): |
| 423 |
body['kdc.ip'] = modify['kdc_ip'] |
| 424 |
if modify.get('kdc_vendor'): |
| 425 |
body['kdc.vendor'] = modify['kdc_vendor'] |
| 426 |
if modify.get('kdc_port'): |
| 427 |
body['kdc.port'] = modify['kdc_port'] |
| 428 |
if modify.get('comment'): |
| 429 |
body['comment'] = modify['comment'] |
| 430 |
if modify.get('ad_server_ip'): |
| 431 |
body['ad_server.address'] = modify['ad_server_ip'] |
| 432 |
if modify.get('ad_server_name'): |
| 433 |
body['ad_server.name'] = modify['ad_server_name'] |
| 434 |
if modify.get('admin_server_ip'): |
| 435 |
body['admin_server.address'] = modify['admin_server_ip'] |
| 436 |
if modify.get('admin_server_port'): |
| 437 |
body['admin_server.port'] = modify['admin_server_port'] |
| 438 |
if modify.get('pw_server_ip'): |
| 439 |
body['password_server.address'] = modify['pw_server_ip'] |
| 440 |
if modify.get('pw_server_port'): |
| 441 |
body['password_server.port'] = modify['pw_server_port'] |
| 442 |
if modify.get('clock_skew'): |
| 443 |
body['clock_skew'] = modify['clock_skew'] |
| 444 |
dummy, error = rest_generic.patch_async(self.rest_api, api, self.parameters['realm'], body) |
| 445 |
if error: |
| 446 |
self.module.fail_json(msg='Error modifying Kerberos Realm %s: %s' % (self.parameters['realm'], to_native(error))) |
| 447 |
|
| 448 |
def delete_krbrealm_rest(self): |
| 449 |
api = 'protocols/nfs/kerberos/realms/%s' % self.svm_uuid |
| 450 |
dummy, error = rest_generic.delete_async(self.rest_api, api, self.parameters['realm']) |
| 451 |
if error: |
| 452 |
self.module.fail_json(msg='Error deleting Kerberos Realm configuration %s: %s' % (self.parameters['realm'], to_native(error))) |
| 453 |
|
| 454 |
def apply(self): |
| 455 |
'''Call create/modify/delete operations.''' |
| 456 |
current = self.get_krbrealm() |
| 457 |
cd_action = self.na_helper.get_cd_action(current, self.parameters) |
| 458 |
modify = self.na_helper.get_modified_attributes(current, self.parameters) |
| 459 |
if self.na_helper.changed and not self.module.check_mode: |
| 460 |
if cd_action == 'create': |
| 461 |
self.create_krbrealm() |
| 462 |
elif cd_action == 'delete': |
| 463 |
self.delete_krbrealm() |
| 464 |
elif modify: |
| 465 |
self.modify_krbrealm(modify) |
| 466 |
result = netapp_utils.generate_result(self.na_helper.changed, cd_action, modify) |
| 467 |
self.module.exit_json(**result) |
| 468 |
|
| 469 |
|
| 470 |
def main(): |
| 471 |
'''ONTAP Kerberos Realm''' |
| 472 |
krbrealm = NetAppOntapKerberosRealm() |
| 473 |
krbrealm.apply() |
| 474 |
|
| 475 |
|
| 476 |
if __name__ == '__main__': |
| 477 |
main() |