# Copyright: (c) 2022, Dell Technologies
# Apache License version 2.0 (see MODULE-LICENSE or http://www.apache.org/licenses/LICENSE-2.0.txt)
"""Ansible module for managing NFS server on Unity"""
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = r'''
module: nfsserver
version_added: '1.4.0'
short_description: Manage NFS server on Unity storage system
description:
- Managing the NFS server on the Unity storage system includes creating NFS server, getting NFS server details
and deleting NFS server attributes.
extends_documentation_fragment:
- dellemc.unity.unity
author:
- Meenakshi Dembi (@dembim) <ansible.team@dell.com>
options:
nas_server_name:
description:
- Name of the NAS server on which NFS server will be hosted.
type: str
nas_server_id:
description:
- ID of the NAS server on which NFS server will be hosted.
type: str
nfs_server_id:
description:
- ID of the NFS server.
type: str
host_name:
description:
- Host name of the NFS server.
type: str
nfs_v4_enabled:
description:
- Indicates whether the NFSv4 is enabled on the NAS server.
type: bool
is_secure_enabled:
description:
- Indicates whether the secure NFS is enabled.
type: bool
kerberos_domain_controller_type:
description:
- Type of Kerberos Domain Controller used for secure NFS service.
choices: [CUSTOM, UNIX, WINDOWS]
type: str
kerberos_domain_controller_username:
description:
- Kerberos Domain Controller administrator username.
type: str
kerberos_domain_controller_password:
description:
- Kerberos Domain Controller administrator password.
type: str
is_extended_credentials_enabled:
description:
- Indicates whether support for more than 16 unix groups in a Unix credential.
type: bool
remove_spn_from_kerberos:
description:
- Indicates whether to remove the SPN from Kerberos Domain Controller.
default: true
type: bool
state:
description:
- Define whether the NFS server should exist or not.
choices: [absent, present]
required: true
type: str
notes:
- The I(check_mode) is supported.
- Modify operation for NFS Server is not supported.
- When I(kerberos_domain_controller_type) is C(UNIX), I(kdc_type) in I(nfs_server_details) output is displayed as C(null).
'''
EXAMPLES = r'''
- name: Create NFS server with kdctype as Windows
dellemc.unity.nfsserver:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
nas_server_name: "dummy_nas"
host_name: "dummy_nas23"
is_secure_enabled: True
kerberos_domain_controller_type: "WINDOWS"
kerberos_domain_controller_username: "administrator"
kerberos_domain_controller_password: "Password123!"
is_extended_credentials_enabled: True
nfs_v4_enabled: True
state: "present"
- name: Create NFS server with kdctype as Unix
dellemc.unity.nfsserver:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
nas_server_name: "dummy_nas"
host_name: "dummy_nas23"
is_secure_enabled: True
kerberos_domain_controller_type: "UNIX"
is_extended_credentials_enabled: True
nfs_v4_enabled: True
state: "present"
- name: Get NFS server details
dellemc.unity.nfsserver:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
nas_server_name: "dummy_nas"
state: "present"
- name: Delete NFS server
dellemc.unity.nfsserver:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
nas_server_name: "dummy_nas"
kerberos_domain_controller_username: "administrator"
kerberos_domain_controller_password: "Password123!"
unjoin_server_account: False
state: "absent"
'''
RETURN = r'''
changed:
description: Whether or not the resource has changed.
returned: always
type: bool
sample: true
nfs_server_details:
description: Details of the NFS server.
returned: When NFS server exists
type: dict
contains:
credentials_cache_ttl:
description: Credential cache refresh timeout. Resolution is in minutes. Default value is 15 minutes.
type: str
existed:
description: Indicates if NFS Server exists.
type: bool
host_name:
description: Host name of the NFS server.
type: str
id:
description: Unique identifier of the NFS Server instance.
type: str
is_extended_credentials_enabled:
description: Indicates whether the NFS server supports more than 16 Unix groups in a Unix credential.
type: bool
is_secure_enabled:
description: Indicates whether secure NFS is enabled on the NFS server.
type: bool
kdc_type:
description: Type of Kerberos Domain Controller used for secure NFS service.
type: str
nfs_v4_enabled:
description: Indicates whether NFSv4 is enabled on the NAS server.
type: bool
servicee_principal_name:
description: The Service Principal Name (SPN) for the NFS Server.
type: str
sample: {
"credentials_cache_ttl": "0:15:00",
"existed": true,
"file_interfaces": {
"UnityFileInterfaceList": [
{
"UnityFileInterface": {
"hash": 8778980109421,
"id": "if_37"
}
}
]
},
"hash": 8778980109388,
"host_name": "dummy_nas23.pie.lab.emc.com",
"id": "nfs_51",
"is_extended_credentials_enabled": true,
"is_secure_enabled": true,
"kdc_type": "KdcTypeEnum.WINDOWS",
"nas_server": {
"UnityNasServer": {
"hash": 8778980109412
}
},
"nfs_v4_enabled": true,
"servicee_principal_name": null
}
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.unity.plugins.module_utils.storage.dell \
import utils
LOG = utils.get_logger('nfsserver')
application_type = "Ansible/1.6.0"
class NFSServer(object):
"""Class with NFS server operations"""
def __init__(self):
"""Define all parameters required by this module"""
self.module_params = utils.get_unity_management_host_parameters()
self.module_params.update(get_nfs_server_parameters())
mutually_exclusive = [['nas_server_name', 'nas_server_id']]
required_one_of = [['nfs_server_id', 'nas_server_name', 'nas_server_id']]
# initialize the Ansible module
self.module = AnsibleModule(
argument_spec=self.module_params,
supports_check_mode=True,
mutually_exclusive=mutually_exclusive,
required_one_of=required_one_of
)
utils.ensure_required_libs(self.module)
self.unity_conn = utils.get_unity_unisphere_connection(
self.module.params, application_type)
LOG.info('Check Mode Flag %s', self.module.check_mode)
def get_nfs_server_details(self, nfs_server_id=None, nas_server_id=None):
"""Get NFS server details.
:param: nfs_server_id: The ID of the NFS server
:param: nas_server_id: The name of the NAS server
:return: Dict containing NFS server details if exists
"""
LOG.info("Getting NFS server details")
try:
if nfs_server_id:
nfs_server_details = self.unity_conn.get_nfs_server(_id=nfs_server_id)
return nfs_server_details._get_properties()
elif nas_server_id:
nfs_server_details = self.unity_conn.get_nfs_server(nas_server=nas_server_id)
if len(nfs_server_details) > 0:
return process_dict(nfs_server_details._get_properties())
return None
except utils.HttpError as e:
if e.http_status == 401:
msg = 'Incorrect username or password provided.'
LOG.error(msg)
self.module.fail_json(msg=msg)
else:
err_msg = "Failed to get details of NFS Server" \
" with error {0}".format(str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
except utils.UnityResourceNotFoundError as e:
err_msg = "Failed to get details of NFS Server" \
" with error {0}".format(str(e))
LOG.error(err_msg)
return None
def get_nfs_server_instance(self, nfs_server_id):
"""Get NFS server instance.
:param: nfs_server_id: The ID of the NFS server
:return: Return NFS server instance if exists
"""
try:
nfs_server_obj = self.unity_conn.get_nfs_server(_id=nfs_server_id)
return nfs_server_obj
except Exception as e:
error_msg = "Failed to get the NFS server %s instance" \
" with error %s" % (nfs_server_id, str(e))
LOG.error(error_msg)
self.module.fail_json(msg=error_msg)
def delete_nfs_server(self, nfs_server_id, skip_unjoin=None, domain_username=None, domain_password=None):
"""Delete NFS server.
:param: nfs_server_id: The ID of the NFS server
:param: skip_unjoin: Flag indicating whether to unjoin SMB server account from AD before deletion
:param: domain_username: The domain username
:param: domain_password: The domain password
:return: Return True if NFS server is deleted
"""
LOG.info("Deleting NFS server")
try:
if not self.module.check_mode:
nfs_obj = self.get_nfs_server_instance(nfs_server_id=nfs_server_id)
nfs_obj.delete(skip_kdc_unjoin=skip_unjoin, username=domain_username, password=domain_password)
return True
except Exception as e:
msg = "Failed to delete NFS server: %s with error: %s" % (nfs_server_id, str(e))
LOG.error(msg)
self.module.fail_json(msg=msg)
def get_nas_server_id(self, nas_server_name):
"""Get NAS server ID.
:param: nas_server_name: The name of NAS server
:return: Return NAS server ID if exists
"""
LOG.info("Getting NAS server ID")
try:
obj_nas = self.unity_conn.get_nas_server(name=nas_server_name)
return obj_nas.get_id()
except Exception as e:
msg = "Failed to get details of NAS server: %s with error: %s" % (nas_server_name, str(e))
LOG.error(msg)
self.module.fail_json(msg=msg)
def is_modification_required(self, is_extended_credentials_enabled, nfs_server_details):
"""Check if modification is required in existing NFS server
:param: is_extended_credentials_enabled: Indicates whether the NFS server supports more than 16 Unix groups in a Unix credential.
:param: nfs_server_details: NFS server details
:return: True if modification is required
"""
LOG.info("Checking if any modification is required")
# Check for Extend Credential
if is_extended_credentials_enabled is not None and \
is_extended_credentials_enabled != nfs_server_details['is_extended_credentials_enabled']:
return True
def create_nfs_server(self, nas_server_id, host_name=None, nfs_v4_enabled=None, is_secure_enabled=None,
kerberos_domain_controller_type=None, kerberos_domain_controller_username=None,
kerberos_domain_controller_password=None, is_extended_credentials_enabled=None):
"""Create NFS server.
:param: nas_server_id: The ID of NAS server.
:param: host_name: Name of NFS Server.
:param: nfs_v4_enabled: Indicates whether the NFSv4 is enabled on the NAS server.
:param: is_secure_enabled: Indicates whether the secure NFS is enabled.
:param: kerberos_domain_controller_type: Type of Kerberos Domain Controller used for secure NFS service.
:param: kerberos_domain_controller_username: Kerberos Domain Controller administrator username.
:param: kerberos_domain_controller_password: Kerberos Domain Controller administrator password.
:param: is_extended_credentials_enabled: Indicates whether support for more than 16 unix groups in a Unix credential.
"""
LOG.info("Creating NFS server")
try:
if not self.module.check_mode:
kdc_enum_type = get_enum_kdctype(kerberos_domain_controller_type)
if kerberos_domain_controller_type == "UNIX":
is_extended_credentials_enabled = None
is_secure_enabled = None
utils.UnityNfsServer.create(cli=self.unity_conn._cli, nas_server=nas_server_id, host_name=host_name,
nfs_v4_enabled=nfs_v4_enabled,
is_secure_enabled=is_secure_enabled, kdc_type=kdc_enum_type,
kdc_username=kerberos_domain_controller_username,
kdc_password=kerberos_domain_controller_password,
is_extended_credentials_enabled=is_extended_credentials_enabled)
return True
except Exception as e:
msg = "Failed to create NFS server with on NAS Server %s with error: %s" % (nas_server_id, str(e))
LOG.error(msg)
self.module.fail_json(msg=msg)
def validate_input_params(self):
param_list = ["nfs_server_id", "nas_server_id", "nas_server_name", "host_name", "kerberos_domain_controller_username",
"kerberos_domain_controller_password"]
for param in param_list:
msg = "Please provide valid value for: %s" % param
if self.module.params[param] is not None and len(self.module.params[param].strip()) == 0:
errmsg = msg.format(param)
self.module.fail_json(msg=errmsg)
def perform_module_operation(self):
"""
Perform different actions on NFS server module based on parameters
passed in the playbook
"""
nfs_server_id = self.module.params['nfs_server_id']
nas_server_id = self.module.params['nas_server_id']
nas_server_name = self.module.params['nas_server_name']
host_name = self.module.params['host_name']
nfs_v4_enabled = self.module.params['nfs_v4_enabled']
is_secure_enabled = self.module.params['is_secure_enabled']
kerberos_domain_controller_type = self.module.params['kerberos_domain_controller_type']
kerberos_domain_controller_username = self.module.params['kerberos_domain_controller_username']
kerberos_domain_controller_password = self.module.params['kerberos_domain_controller_password']
is_extended_credentials_enabled = self.module.params['is_extended_credentials_enabled']
remove_spn_from_kerberos = self.module.params['remove_spn_from_kerberos']
state = self.module.params['state']
# result is a dictionary that contains changed status and NFS server details
result = dict(
changed=False,
nfs_server_details={}
)
modify_flag = False
self.validate_input_params()
if nas_server_name:
nas_server_id = self.get_nas_server_id(nas_server_name)
nfs_server_details = self.get_nfs_server_details(nfs_server_id=nfs_server_id,
nas_server_id=nas_server_id)
# Check if modification is required
if nfs_server_details and state == 'present':
modify_flag = self.is_modification_required(is_extended_credentials_enabled, nfs_server_details)
if modify_flag:
self.module.fail_json(msg="Modification of NFS Server parameters is not supported through Ansible module")
if not nfs_server_details and state == 'present':
if not nas_server_id:
self.module.fail_json(msg="Please provide nas server id/name to create NFS server.")
result['changed'] = self.create_nfs_server(nas_server_id, host_name, nfs_v4_enabled,
is_secure_enabled, kerberos_domain_controller_type,
kerberos_domain_controller_username,
kerberos_domain_controller_password,
is_extended_credentials_enabled)
if state == 'absent' and nfs_server_details:
skip_unjoin = not remove_spn_from_kerberos
result['changed'] = self.delete_nfs_server(nfs_server_details["id"], skip_unjoin,
kerberos_domain_controller_username,
kerberos_domain_controller_password)
if state == 'present':
result['nfs_server_details'] = self.get_nfs_server_details(nfs_server_id=nfs_server_id,
nas_server_id=nas_server_id)
self.module.exit_json(**result)
def get_nfs_server_parameters():
"""This method provide parameters required for the ansible
NFS server module on Unity"""
return dict(
nfs_server_id=dict(type='str'),
host_name=dict(type='str'),
nfs_v4_enabled=dict(type='bool'),
is_secure_enabled=dict(type='bool'),
kerberos_domain_controller_type=dict(type='str', choices=['UNIX', 'WINDOWS', 'CUSTOM']),
kerberos_domain_controller_username=dict(type='str'),
kerberos_domain_controller_password=dict(type='str', no_log=True),
nas_server_name=dict(type='str'),
nas_server_id=dict(type='str'),
is_extended_credentials_enabled=dict(type='bool'),
remove_spn_from_kerberos=dict(default=True, type='bool'),
state=dict(required=True, type='str', choices=['present', 'absent']),
)
def get_enum_kdctype(kerberos_domain_controller_type):
"""Getting correct enum values for kerberos_domain_controller_type
:param: kerberos_domain_controller_type: Type of Kerberos Domain Controller used for secure NFS service.
:return: enum value for kerberos_domain_controller_type.
"""
if utils.KdcTypeEnum[kerberos_domain_controller_type]:
kerberos_domain_controller_type = utils.KdcTypeEnum[kerberos_domain_controller_type]
return kerberos_domain_controller_type
def process_dict(nfs_server_details):
"""Process NFS server details.
:param: nfs_server_details: Dict containing NFS server details
:return: Processed dict containing NFS server details
"""
param_list = ['credentials_cache_ttl', 'file_interfaces', 'host_name', 'id', 'kdc_type', 'nas_server', 'is_secure_enabled',
'is_extended_credentials_enabled', 'nfs_v4_enabled', 'servicee_principal_name']
for param in param_list:
if param in nfs_server_details and param == 'credentials_cache_ttl':
nfs_server_details[param] = str(nfs_server_details[param][0])
else:
nfs_server_details[param] = nfs_server_details[param][0]
return nfs_server_details
def main():
"""Create Unity NFS server object and perform action on it
based on user input from playbook"""
obj = NFSServer()
obj.perform_module_operation()
if __name__ == '__main__':
main()