# Copyright: (c) 2020, Dell Technologies
# Apache License version 2.0 (see MODULE-LICENSE or http://www.apache.org/licenses/LICENSE-2.0.txt)
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
DOCUMENTATION = r'''
---
module: smbshare
version_added: '1.1.0'
short_description: Manage SMB shares on Unity storage system
extends_documentation_fragment:
- dellemc.unity.unity
author:
- P Srinivas Rao (@srinivas-rao5) <ansible.team@dell.com>
description:
- Managing SMB Shares on Unity storage system includes create, get,
modify, and delete the smb shares.
options:
share_name:
description:
- Name of the SMB share.
- Required during creation of the SMB share.
- For all other operations either I(share_name) or I(share_id) is required.
type: str
share_id:
description:
- ID of the SMB share.
- Should not be specified during creation. Id is auto generated.
- For all other operations either I(share_name) or I(share_id) is required.
- If I(share_id) is used then no need to pass nas_server/filesystem/snapshot/path.
type: str
path:
description:
- Local path to the file system/Snapshot or any existing sub-folder of
the file system/Snapshot that is shared over the network.
- Path is relative to the root of the filesystem.
- Required for creation of the SMB share.
type: str
filesystem_id:
description:
- The ID of the File System.
- Either I(filesystem_name) or I(filesystem_id) is required for creation of the SMB share for filesystem.
- If I(filesystem_name) is specified, then I(nas_server_name)/I(nas_server_id) is required to
uniquely identify the filesystem.
- Options I(filesystem_name) and I(filesystem_id) are mutually exclusive parameters.
type: str
snapshot_id:
description:
- The ID of the Filesystem Snapshot.
- Either I(snapshot_name) or I(snapshot_id) is required for creation of the SMB share for a snapshot.
- If I(snapshot_name) is specified, then I(nas_server_name)/I(nas_server_id) is required to
uniquely identify the snapshot.
- Options I(snapshot_name) and I(snapshot_id) are mutually exclusive parameters.
type: str
nas_server_id:
description:
- The ID of the NAS Server.
- It is not required if I(share_id) is used.
type: str
filesystem_name:
description:
- The Name of the File System.
- Either I(filesystem_name) or I(filesystem_id) is required for creation of the SMB share for filesystem.
- If I(filesystem_name) is specified, then I(nas_server_name)/I(nas_server_id) is required to
uniquely identify the filesystem.
- Options I(filesystem_name) and I(filesytem_id) are mutually exclusive parameters.
type: str
snapshot_name:
description:
- The Name of the Filesystem Snapshot.
- Either I(snapshot_name) or I(snapshot_id) is required for creation of the SMB share for a snapshot.
- If I(snapshot_name) is specified, then I(nas_server_name)/I(nas_server_id) is required to
uniquely identify the snapshot.
- Options I(snapshot_name) and I(snapshot_id) are mutually exclusive parameters.
type: str
nas_server_name:
description:
- The Name of the NAS Server.
- It is not required if I(share_id) is used.
- Options I(nas_server_name) and I(nas_server_id) are mutually exclusive parameters.
type: str
description:
description:
- Description for the SMB share.
- Optional parameter when creating a share.
- To modify, pass the new value in description field.
type: str
is_abe_enabled:
description:
- Indicates whether Access-based Enumeration (ABE) for SMB share is enabled.
- During creation, if not mentioned then default is C(false).
type: bool
is_branch_cache_enabled:
description:
- Indicates whether Branch Cache optimization for SMB share is enabled.
- During creation, if not mentioned then default is C(false).
type: bool
is_continuous_availability_enabled:
description:
- Indicates whether continuous availability for SMB 3.0 is enabled.
- During creation, if not mentioned then default is C(false).
type: bool
is_encryption_enabled:
description:
- Indicates whether encryption for SMB 3.0 is enabled at the shared folder level.
- During creation, if not mentioned then default is C(false).
type: bool
offline_availability:
description:
- Defines valid states of Offline Availability.
- C(MANUAL)- Only specified files will be available offline.
- C(DOCUMENTS)- All files that users open will be available offline.
- C(PROGRAMS)- Program will preferably run from the offline cache even when
connected to the network. All files that users open will be available offline.
- C(NONE)- Prevents clients from storing documents and programs in offline cache.
type: str
choices: ["MANUAL","DOCUMENTS","PROGRAMS","NONE"]
umask:
description:
- The default UNIX umask for new files created on the SMB Share.
type: str
state:
description:
- Define whether the SMB share should exist or not.
- Value C(present) indicates that the share should exist on the system.
- Value C(absent) indicates that the share should not exist on the system.
type: str
required: true
choices: ['absent', 'present']
notes:
- When ID/Name of the filesystem/snapshot is passed then I(nas_server) is not required.
If passed, then filesystem/snapshot should exist for the mentioned I(nas_server),
else the task will fail.
- The I(check_mode) is not supported.
'''
EXAMPLES = r'''
- name: Create SMB share for a filesystem
dellemc.unity.smbshare:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
share_name: "sample_smb_share"
filesystem_name: "sample_fs"
nas_server_id: "NAS_11"
path: "/sample_fs"
description: "Sample SMB share created"
is_abe_enabled: True
is_branch_cache_enabled: True
offline_availability: "DOCUMENTS"
is_continuous_availability_enabled: True
is_encryption_enabled: True
umask: "777"
state: "present"
- name: Modify Attributes of SMB share for a filesystem
dellemc.unity.smbshare:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
share_name: "sample_smb_share"
nas_server_name: "sample_nas_server"
description: "Sample SMB share attributes updated"
is_abe_enabled: False
is_branch_cache_enabled: False
offline_availability: "MANUAL"
is_continuous_availability_enabled: "False"
is_encryption_enabled: "False"
umask: "022"
state: "present"
- name: Create SMB share for a snapshot
dellemc.unity.smbshare:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
share_name: "sample_snap_smb_share"
snapshot_name: "sample_snapshot"
nas_server_id: "NAS_11"
path: "/sample_snapshot"
description: "Sample SMB share created for snapshot"
is_abe_enabled: True
is_branch_cache_enabled: True
is_continuous_availability_enabled: True
is_encryption_enabled: True
umask: "777"
state: "present"
- name: Modify Attributes of SMB share for a snapshot
dellemc.unity.smbshare:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
share_name: "sample_snap_smb_share"
snapshot_name: "sample_snapshot"
description: "Sample SMB share attributes updated for snapshot"
is_abe_enabled: False
is_branch_cache_enabled: False
offline_availability: "MANUAL"
is_continuous_availability_enabled: "False"
is_encryption_enabled: "False"
umask: "022"
state: "present"
- name: Get details of SMB share
dellemc.unity.smbshare:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
share_id: "{{smb_share_id}}"
state: "present"
- name: Delete SMB share
dellemc.unity.smbshare:
unispherehost: "{{unispherehost}}"
username: "{{username}}"
password: "{{password}}"
validate_certs: "{{validate_certs}}"
share_id: "{{smb_share_id}}"
state: "absent"
'''
RETURN = r'''
changed:
description: Whether or not the resource has changed.
returned: always
type: bool
sample: True
smb_share_details:
description: The SMB share details.
type: dict
returned: When share exists.
contains:
id:
description: The ID of the SMB share.
type: str
name:
description: Name of the SMB share.
type: str
sample: "sample_smb_share"
filesystem_id:
description: The ID of the Filesystem.
type: str
filesystem_name:
description: The Name of the filesystem
type: str
snapshot_id:
description: The ID of the Snapshot.
type: str
snapshot_name:
description: The Name of the Snapshot.
type: str
nas_server_id:
description: The ID of the nas_server.
type: str
nas_server_name:
description: The Name of the nas_server.
type: str
description:
description: Additional information about the share.
type: str
sample: This share is created for demo purpose only.
is_abe_enabled:
description: Whether Access Based enumeration is enforced or not.
type: bool
sample: false
is_branch_cache_enabled:
description: Whether branch cache is enabled or not.
type: bool
sample: false
is_continuous_availability_enabled:
description: Whether the share will be available continuously or not.
type: bool
sample: false
is_encryption_enabled:
description: Whether encryption is enabled or not.
type: bool
sample: false
umask:
description: Unix mask for the SMB share.
type: str
sample: {
"creation_time": "2022-03-17 11:56:54.867000+00:00",
"description": "",
"existed": true,
"export_paths": [
"\\\\multi-prot-pie.extreme1.com\\multi-prot-hui",
"\\\\10.230.24.26\\multi-prot-hui"
],
"filesystem": {
"UnityFileSystem": {
"hash": 8748426746492
}
},
"filesystem_id": "fs_140",
"filesystem_name": "multi-prot-hui",
"hash": 8748426746588,
"id": "SMBShare_20",
"is_abe_enabled": false,
"is_ace_enabled": false,
"is_branch_cache_enabled": false,
"is_continuous_availability_enabled": false,
"is_dfs_enabled": false,
"is_encryption_enabled": false,
"is_read_only": null,
"modified_time": "2022-03-17 11:56:54.867000+00:00",
"name": "multi-prot-hui",
"nas_server_id": "nas_5",
"nas_server_name": "multi-prot",
"offline_availability": "CifsShareOfflineAvailabilityEnum.NONE",
"path": "/",
"snap": null,
"type": "CIFSTypeEnum.CIFS_SHARE",
"umask": "022"
}
'''
from ansible.module_utils.basic import AnsibleModule
from ansible_collections.dellemc.unity.plugins.module_utils.storage.dell \
import utils
LOG = utils.get_logger('smbshare')
application_type = "Ansible/1.6.0"
class SMBShare(object):
"""Class with SMB Share 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_smb_share_parameters())
# initialize the ansible module
mut_ex_args = [['share_name', 'share_id'],
['nas_server_name', 'nas_server_id'],
['filesystem_name', 'snapshot_name',
'filesystem_id', 'snapshot_id'],
['share_id', 'nas_server_name'],
['share_id', 'nas_server_id'],
['share_id', 'filesystem_name'],
['share_id', 'filesystem_id'],
['share_id', 'path'],
['share_id', 'snapshot_name'],
['share_id', 'snapshot_id']]
required_one_of = [['share_id', 'share_name']]
self.module = AnsibleModule(
argument_spec=self.module_params,
supports_check_mode=False,
mutually_exclusive=mut_ex_args,
required_one_of=required_one_of
)
utils.ensure_required_libs(self.module)
# result is a dictionary that contains changed status and
# snapshot details
self.result = {"changed": False,
'smb_share_details': {}}
self.unity_conn = utils.get_unity_unisphere_connection(
self.module.params, application_type)
self.smb_share_conn_obj = utils.cifs_share.UnityCifsShare(
self.unity_conn)
LOG.info('Connection established with the Unity Array')
def get_offline_availability_enum(self, offline_availability):
"""
Get the enum of the Offline Availability parameter.
:param offline_availability: The offline_availability string
:return: offline_availability enum
"""
if offline_availability in \
utils.CifsShareOfflineAvailabilityEnum.__members__:
return utils.CifsShareOfflineAvailabilityEnum[
offline_availability]
else:
error_msg = "Invalid value {0} for offline availability" \
" provided".format(offline_availability)
LOG.error(error_msg)
self.module.fail_json(msg=error_msg)
def get_smb_share_obj(self, share_id=None, share_name=None,
filesystem_obj=None, snap_obj=None, nas_obj=None):
"""Get SMB share details"""
msg = "Failed to get details of SMB Share {0} with error {1} "
smb_share = share_name if share_name else share_id
try:
if share_id:
obj_smb = self.unity_conn.get_cifs_share(_id=share_id)
if obj_smb and obj_smb.existed:
LOG.info("Successfully got the SMB share "
"object %s ", obj_smb)
return obj_smb
elif share_name is not None and filesystem_obj:
# There might be a case where SMB share with same name exists
# for different nas server. Hence, filesystem_obj is passed
# along with share name to get a unique resource.
return self.unity_conn.get_cifs_share(
name=share_name, filesystem=filesystem_obj)
elif share_name is not None and snap_obj:
# There might be a case where SMB share with same name exists
# for different nas server. Hence, snap_obj is passed
# along with share name to get a unique resource.
return self.unity_conn.get_cifs_share(
name=share_name, snap=snap_obj)
# This elif is addressing scenario where nas server details is
# passed and neither filesystem nor snapshot details are passed.
elif share_name is not None and nas_obj:
# Multiple smb shares can be received, as only name is passed
smb_share_obj = self.unity_conn.get_cifs_share(
name=share_name)
# Checking if instance or list of instance is returned.
if isinstance(smb_share_obj,
utils.cifs_share.UnityCifsShareList):
LOG.info("Multiple SMB share with same name found.")
smb_share_obj_list = smb_share_obj
for smb_share in smb_share_obj_list:
if smb_share.filesystem.nas_server == nas_obj:
return smb_share
msg = "No SMB share found with the given NAS Server." \
" Please provide correct share name and" \
" nas server details."
return None
# Below statements will execute when there is only single
# smb share returned.
if smb_share_obj.filesystem.nas_server == nas_obj:
return smb_share_obj
msg = "No SMB share found with the given NAS Server." \
" Please provide correct share name and" \
" nas server details."
return None
else:
self.module.fail_json(
msg="Share Name is Passed. Please enter Filesystem/"
"Snapshot/NAS Server Resource along with share_name"
" to get the details of the SMB share")
except utils.HttpError as e:
if e.http_status == 401:
cred_err = "Incorrect username or password , {0}".format(
e.message)
self.module.fail_json(msg=cred_err)
else:
err_msg = msg.format(smb_share, str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
except utils.UnityResourceNotFoundError as e:
err_msg = msg.format(smb_share, str(e))
LOG.error(err_msg)
return None
except Exception as e:
err_msg = msg.format(smb_share, str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
def create_smb_share(self, share_name, path, filesystem_obj=None,
snapshot_obj=None, description=None,
is_abe_enabled=None, is_branch_cache_enabled=None,
is_continuous_availability_enabled=None,
is_encryption_enabled=None,
offline_availability=None, umask=None):
"""
Create SMB Share
:return: SMB Share Object if successful, else error.
"""
if path is None or path == "":
self.module.fail_json(msg="Please enter a valid path."
" Empty string or None provided.")
if not filesystem_obj and not snapshot_obj:
self.module.fail_json(msg="Either Filesystem or Snapshot "
"Resource's Name/ID is required to"
" Create a SMB share")
try:
if filesystem_obj:
return self.smb_share_conn_obj.create(
cli=self.unity_conn._cli, name=share_name,
fs=filesystem_obj, path=path,
is_encryption_enabled=is_encryption_enabled,
is_con_avail_enabled=is_continuous_availability_enabled,
is_abe_enabled=is_abe_enabled,
is_branch_cache_enabled=is_branch_cache_enabled,
umask=umask, description=description,
offline_availability=offline_availability)
else:
return self.smb_share_conn_obj.create_from_snap(
cli=self.unity_conn._cli, name=share_name,
snap=snapshot_obj, path=path,
is_encryption_enabled=is_encryption_enabled,
is_con_avail_enabled=is_continuous_availability_enabled,
is_abe_enabled=is_abe_enabled,
is_branch_cache_enabled=is_branch_cache_enabled,
umask=umask, description=description,
offline_availability=offline_availability)
except Exception as e:
error_msg = "Failed to create SMB share" \
" %s with error %s" % (share_name, str(e))
LOG.error(error_msg)
self.module.fail_json(msg=error_msg)
def get_filesystem(self, filesystem_id=None, filesystem_name=None,
nas_server_obj=None):
"""
Get the Filesystem Object.
:param filesystem_id: ID of the Filesystem.
:param filesystem_name: Name of the filesystem.
:param nas_server_obj: NAS Server object.
:return: Object of the filesystem.
"""
try:
if filesystem_id:
obj_fs = self.unity_conn.get_filesystem(_id=filesystem_id)
if obj_fs and obj_fs.existed:
LOG.info("Successfully got the filesystem "
"object %s ", obj_fs)
return obj_fs
else:
return self.unity_conn.get_filesystem(
name=filesystem_name, nas_server=nas_server_obj)
return None
except Exception as e:
filesystem = filesystem_name if filesystem_name \
else filesystem_id
err_msg = "Failed to get filesystem details {0} with" \
" error {1}".format(filesystem, str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
def get_snapshot(self, snapshot_name, snapshot_id):
"""
Get the Snapshot Object.
:param snapshot_id: ID of the Snapshot.
:param snapshot_name: Name of the Snapshot
:return: Object of the filesystem.
"""
try:
obj_snap = self.unity_conn.get_snap(_id=snapshot_id,
name=snapshot_name)
if snapshot_id and obj_snap and not obj_snap.existed:
LOG.info("Snapshot object does not exist %s ", obj_snap)
return None
return obj_snap
except Exception as e:
snapshot = snapshot_name if snapshot_name else snapshot_id
err_msg = "Failed to get filesystem snapshots details {0} with" \
" error {1}".format(snapshot, str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
def get_nas_server(self, nas_server_name, nas_server_id):
"""
Get the NAS Server Object using NAME/ID of the NAS Server.
:param nas_server_name: Name of the NAS Server
:param nas_server_id: ID of the NAS Server
:return: NAS Server object.
"""
nas_server = nas_server_name if nas_server_name else nas_server_id
try:
obj_nas = self.unity_conn.get_nas_server(_id=nas_server_id,
name=nas_server_name)
if nas_server_id and obj_nas and not obj_nas.existed:
LOG.info("NAS Server object does not exist %s ", obj_nas)
return None
return obj_nas
except utils.HttpError as e:
if e.http_status == 401:
cred_err = "Incorrect username or password , {0}".format(
e.message)
self.module.fail_json(msg=cred_err)
else:
err_msg = "Failed to get details of NAS Server" \
" {0} with error {1}".format(nas_server, str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
except Exception as e:
nas_server = nas_server_name if nas_server_name \
else nas_server_id
err_msg = "Failed to get nas server details {0} with" \
" error {1}".format(nas_server, str(e))
LOG.error(err_msg)
self.module.fail_json(msg=err_msg)
def delete_smb_share(self, smb_share_obj):
"""
Delete SMB share if exists, else thrown error.
"""
try:
smb_share_obj.delete()
except Exception as e:
error_msg = "Failed to Delete SMB share" \
" %s with error %s" % (smb_share_obj.name, str(e))
LOG.error(error_msg)
self.module.fail_json(msg=error_msg)
def to_update(self, smb_share_obj):
LOG.info("Checking Whether the parameters are modified or not.")
offline_availability = self.module.params['offline_availability']
# Get the enum for the corresponding offline_availability
if offline_availability:
offline_availability = \
self.get_offline_availability_enum(offline_availability)
if offline_availability is not None and \
offline_availability != smb_share_obj.offline_availability:
return True
smb_share_dict = smb_share_obj._get_properties()
params_list = ['is_abe_enabled', 'is_branch_cache_enabled',
'is_continuous_availability_enabled',
'is_encryption_enabled', 'description', 'umask']
for param in params_list:
if self.module.params[param] is not None and \
self.module.params[param] != smb_share_dict[param]:
return True
return False
def update_smb_share(self, smb_share_obj, is_encryption_enabled=None,
is_continuous_availability_enabled=None,
is_abe_enabled=None,
is_branch_cache_enabled=None,
umask=None, description=None,
offline_availability=None):
"""
The Details of the SMB share will be updated in the function.
"""
try:
smb_share_obj.modify(
is_encryption_enabled=is_encryption_enabled,
is_con_avail_enabled=is_continuous_availability_enabled,
is_abe_enabled=is_abe_enabled,
is_branch_cache_enabled=is_branch_cache_enabled,
umask=umask, description=description,
offline_availability=offline_availability)
except Exception as e:
error_msg = "Failed to Update parameters of SMB share" \
" %s with error %s" % (smb_share_obj.name, str(e))
LOG.error(error_msg)
self.module.fail_json(msg=error_msg)
def perform_module_operation(self):
"""
Perform different actions on SMB share based on user parameters
chosen in playbook
"""
state = self.module.params['state']
share_name = self.module.params['share_name']
filesystem_name = self.module.params['filesystem_name']
snapshot_name = self.module.params['snapshot_name']
nas_server_name = self.module.params['nas_server_name']
share_id = self.module.params['share_id']
filesystem_id = self.module.params['filesystem_id']
snapshot_id = self.module.params['snapshot_id']
nas_server_id = self.module.params['nas_server_id']
path = self.module.params['path']
description = self.module.params['description']
is_branch_cache_enabled = \
self.module.params['is_branch_cache_enabled']
is_continuous_availability_enabled = \
self.module.params['is_continuous_availability_enabled']
is_encryption_enabled = self.module.params['is_encryption_enabled']
is_abe_enabled = self.module.params['is_abe_enabled']
umask = self.module.params['umask']
offline_availability = self.module.params['offline_availability']
# Get the enum for the corresponding offline_availability
if offline_availability:
offline_availability = \
self.get_offline_availability_enum(offline_availability)
changed = False
'''
Validate parameters.
'''
if share_id is not None and \
(share_id == "" or len(share_id.split()) == 0):
self.module.fail_json(msg="Invalid share id provided."
" Please enter a valid share ID.")
'''
Get details of NAS Server, if entered.
'''
nas_server_obj = None
if nas_server_name or nas_server_id:
nas_server_obj = self.get_nas_server(nas_server_name,
nas_server_id)
if nas_server_obj:
msg = "NAS Server Object:" \
" {0}".format(nas_server_obj._get_properties())
LOG.info(msg)
else:
msg = "NAS Server Resource not fetched."
LOG.info(msg)
'''
Get details of Filesystem, if entered.
'''
filesystem_obj = None
if filesystem_id:
filesystem_obj = self.get_filesystem(filesystem_id)
if filesystem_name:
# nas_server_obj is required to uniquely identify filesystem
# resource. If neither nas_server_name nor nas_server_id
# is passed along with filesystem_name then error is thrown.
if not nas_server_obj:
self.module.fail_json(msg="nas_server_id/nas_server_name is "
"required when filesystem_name is "
"passed")
filesystem_obj = self.get_filesystem(
None, filesystem_name, nas_server_obj)
if filesystem_obj:
msg = "Filesystem Object:" \
" {0}".format(filesystem_obj._get_properties())
LOG.info(msg)
# Checking if filesystem supports SMB protocol or not.
if filesystem_obj and \
filesystem_obj.supported_protocols.name == "NFS":
self.module.fail_json(msg="Cannot perform SMB share operations "
"as file system supports only NFS "
"protocol. Please enter a valid "
"Filesystem having supported protocol"
" as SMB or Multiprotocol.")
'''
Get details of Snapshot, if entered.
'''
snapshot_obj = None
if snapshot_id or snapshot_name:
# Snapshot Name and Snapshot ID both are unique across array.
# Hence no need to mention nas server details
snapshot_obj = self.get_snapshot(snapshot_name, snapshot_id)
if snapshot_obj:
msg = "Snapshot Object:" \
" {0}".format(snapshot_obj._get_properties())
LOG.info(msg)
else:
msg = "Snapshot Resource not fetched."
LOG.info(msg)
'''
Get the Details of the SMB Share
'''
smb_share_obj = self.get_smb_share_obj(
share_id, share_name, filesystem_obj, snapshot_obj,
nas_server_obj)
if smb_share_obj:
msg = "SMB Share Object:" \
" {0}".format(smb_share_obj._get_properties())
LOG.info(msg)
elif state == 'present' and share_id:
msg = "Unable to fetch SMB Share Resource. " \
"Incorrect SMB share id provided. " \
"Please enter a correct share id."
LOG.error(msg)
self.module.fail_json(msg=msg)
'''
Creation of SMB Share
'''
if state == "present" and not smb_share_obj:
smb_share_obj = self.create_smb_share(
share_name, path, filesystem_obj, snapshot_obj, description,
is_abe_enabled, is_branch_cache_enabled,
is_continuous_availability_enabled, is_encryption_enabled,
offline_availability, umask)
changed = True
'''
Update the SMB share details
'''
if state == "present" and smb_share_obj:
LOG.info("Modify the details of the SMB share.")
update_flag = self.to_update(smb_share_obj)
msg = "Update Flag: {0}".format(str(update_flag))
LOG.info(msg)
if update_flag:
self.update_smb_share(smb_share_obj, is_encryption_enabled,
is_continuous_availability_enabled,
is_abe_enabled,
is_branch_cache_enabled,
umask, description,
offline_availability)
changed = True
'''
Delete the SMB share details
'''
if state == "absent" and smb_share_obj:
self.delete_smb_share(smb_share_obj)
changed = True
'''
Update the changed state and SMB share details
'''
self.result["changed"] = changed
smb_details = self.prepare_output_dict(state, share_id, share_name,
filesystem_obj, snapshot_obj,
nas_server_obj)
self.result["smb_share_details"] = smb_details
self.module.exit_json(**self.result)
def prepare_output_dict(self, state, share_id, share_name,
filesystem_obj, snapshot_obj, nas_server_obj):
smb_share_details = None
smb_share_obj = None
if state == 'present':
smb_share_obj = self.get_smb_share_obj(
share_id, share_name, filesystem_obj,
snapshot_obj, nas_server_obj)
smb_share_details = smb_share_obj._get_properties()
if smb_share_details:
# Get Snapshot NAME and ID if SMB share exists for Snapshot
if smb_share_obj.type.name == "CIFS_SNAPSHOT":
smb_share_details['snapshot_name'] = smb_share_obj.snap.name
smb_share_details['snapshot_id'] = smb_share_obj.snap.id
# Get Filesystem NAME and ID
smb_share_details['filesystem_name'] = \
smb_share_obj.filesystem.name
smb_share_details['filesystem_id'] = smb_share_obj.filesystem.id
# Get NAS server NAME and ID
smb_share_details['nas_server_name'] = \
smb_share_obj.filesystem.nas_server.name
smb_share_details['nas_server_id'] = \
smb_share_obj.filesystem.nas_server.id
return smb_share_details
def get_smb_share_parameters():
"""
This method provides parameters required for the ansible smb share
modules on Unity
"""
return dict(
share_name=dict(), share_id=dict(),
filesystem_name=dict(), filesystem_id=dict(),
snapshot_name=dict(), snapshot_id=dict(),
nas_server_name=dict(), nas_server_id=dict(),
path=dict(no_log=True), umask=dict(), description=dict(),
offline_availability=dict(
choices=["MANUAL", "DOCUMENTS", "PROGRAMS", "NONE"]),
is_abe_enabled=dict(type='bool'),
is_branch_cache_enabled=dict(type='bool'),
is_continuous_availability_enabled=dict(type='bool'),
is_encryption_enabled=dict(type='bool'),
state=dict(required=True, choices=['present', 'absent'], type='str')
)
def main():
""" Create Unity SMB share object and perform action on it
based on user input from playbook"""
obj = SMBShare()
obj.perform_module_operation()
if __name__ == '__main__':
main()