Init: mediaserver

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/doc_fragments/netapp.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+# Copyright: (c) 2019, NetApp Ansible Team <ng-ansibleteam@netapp.com>
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+
+class ModuleDocFragment(object):
+
+    DOCUMENTATION = r'''
+options:
+  - See respective platform section for more details
+requirements:
+  - See respective platform section for more details
+notes:
+  - This is documentation for NetApp's AWS CVS modules.
+'''
+
+    # Documentation fragment for AWSCVS
+    AWSCVS = """
+options:
+  api_key:
+    required: true
+    type: str
+    description:
+    - The access key to authenticate with the AWSCVS Web Services Proxy or Embedded Web Services API.
+  secret_key:
+    required: true
+    type: str
+    description:
+    - The secret_key to authenticate with the AWSCVS Web Services Proxy or Embedded Web Services API.
+  api_url:
+    required: true
+    type: str
+    description:
+    - The url to the AWSCVS Web Services Proxy or Embedded Web Services API.
+  validate_certs:
+    required: false
+    default: true
+    description:
+    - Should https certificates be validated?
+    type: bool
+  feature_flags:
+      description:
+      - Enable or disable a new feature.
+      - This can be used to enable an experimental feature or disable a new feature that breaks backward compatibility.
+      - Supported keys and values are subject to change without notice.  Unknown keys are ignored.
+      - trace_apis can be set to true to enable tracing, data is written to /tmp/um_apis.log.
+      type: dict
+      version_added: 21.6.0
+notes:
+  - The modules prefixed with aws\\_cvs\\_netapp are built to Manage AWS Cloud Volumes Service .
+"""

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/module_utils/netapp.py

@@ -0,0 +1,241 @@
+# This code is part of Ansible, but is an independent component.
+# This particular file snippet, and this file snippet only, is BSD licensed.
+# Modules you write using this snippet, which is embedded dynamically by Ansible
+# still belong to the author of the module, and may assign their own license
+# to the complete work.
+#
+# Copyright (c) 2019, NetApp Ansible Team <ng-ansibleteam@netapp.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright notice,
+#      this list of conditions and the following disclaimer in the documentation
+#      and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+'''
+netapp.py
+Support methods and class for AWS CVS modules
+'''
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import logging
+import time
+from ansible.module_utils.basic import missing_required_lib
+
+try:
+    from ansible.module_utils.ansible_release import __version__ as ansible_version
+except ImportError:
+    ansible_version = 'unknown'
+
+COLLECTION_VERSION = "21.7.0"
+
+try:
+    import requests
+    HAS_REQUESTS = True
+except ImportError:
+    HAS_REQUESTS = False
+
+
+POW2_BYTE_MAP = dict(
+    # Here, 1 kb = 1024
+    bytes=1,
+    b=1,
+    kb=1024,
+    mb=1024 ** 2,
+    gb=1024 ** 3,
+    tb=1024 ** 4,
+    pb=1024 ** 5,
+    eb=1024 ** 6,
+    zb=1024 ** 7,
+    yb=1024 ** 8
+)
+
+LOG = logging.getLogger(__name__)
+LOG_FILE = '/tmp/aws_cvs_apis.log'
+
+
+def aws_cvs_host_argument_spec():
+
+    return dict(
+        api_url=dict(required=True, type='str'),
+        validate_certs=dict(required=False, type='bool', default=True),
+        api_key=dict(required=True, type='str', no_log=True),
+        secret_key=dict(required=True, type='str', no_log=True),
+        feature_flags=dict(required=False, type='dict', default=dict()),
+    )
+
+
+def has_feature(module, feature_name):
+    feature = get_feature(module, feature_name)
+    if isinstance(feature, bool):
+        return feature
+    module.fail_json(msg="Error: expected bool type for feature flag: %s" % feature_name)
+
+
+def get_feature(module, feature_name):
+    ''' if the user has configured the feature, use it
+        otherwise, use our default
+    '''
+    default_flags = dict(
+        strict_json_check=True,                 # if true, fail if response.content in not empty and is not valid json
+        trace_apis=False,                       # if true, append REST requests/responses to LOG_FILE
+    )
+
+    if module.params['feature_flags'] is not None and feature_name in module.params['feature_flags']:
+        return module.params['feature_flags'][feature_name]
+    if feature_name in default_flags:
+        return default_flags[feature_name]
+    module.fail_json(msg="Internal error: unexpected feature flag: %s" % feature_name)
+
+
+class AwsCvsRestAPI(object):
+    ''' wraps requests methods to interface with AWS CVS REST APIs '''
+    def __init__(self, module, timeout=60):
+        self.module = module
+        self.api_key = self.module.params['api_key']
+        self.secret_key = self.module.params['secret_key']
+        self.api_url = self.module.params['api_url']
+        self.verify = self.module.params['validate_certs']
+        self.timeout = timeout
+        self.url = 'https://' + self.api_url + '/v1/'
+        self.errors = list()
+        self.debug_logs = list()
+        self.check_required_library()
+        if has_feature(module, 'trace_apis'):
+            logging.basicConfig(filename=LOG_FILE, level=logging.DEBUG, format='%(asctime)s %(levelname)-8s %(message)s')
+
+    def check_required_library(self):
+        if not HAS_REQUESTS:
+            self.module.fail_json(msg=missing_required_lib('requests'))
+
+    def send_request(self, method, api, params, json=None):
+        ''' send http request and process reponse, including error conditions '''
+        if params is not None:
+            self.module.fail_json(msg='params is not implemented.  api=%s, params=%s' % (api, repr(params)))
+        url = self.url + api
+        status_code = None
+        content = None
+        json_dict = None
+        json_error = None
+        error_details = None
+        headers = {
+            'Content-type': "application/json",
+            'api-key': self.api_key,
+            'secret-key': self.secret_key,
+            'Cache-Control': "no-cache",
+        }
+
+        def check_contents(response):
+            '''json() may fail on an empty value, but it's OK if no response is expected.
+               To avoid false positives, only report an issue when we expect to read a value.
+               The first get will see it.
+            '''
+            if method == 'GET' and has_feature(self.module, 'strict_json_check'):
+                contents = response.content
+                if len(contents) > 0:
+                    raise ValueError("Expecting json, got: %s" % contents)
+
+        def get_json(response):
+            ''' extract json, and error message if present '''
+            error = None
+            try:
+                json = response.json()
+            except ValueError:
+                check_contents(response)
+                return None, None
+            success_code = [200, 201, 202]
+            if response.status_code not in success_code:
+                error = json.get('message')
+            return json, error
+
+        def sanitize(value, key=None):
+            if isinstance(value, dict):
+                new_dict = dict()
+                for key, value in value.items():
+                    new_dict[key] = sanitize(value, key)
+                return new_dict
+            else:
+                if key in ['api-key', 'secret-key', 'password']:
+                    return '*' * 12
+                else:
+                    return value
+
+        self.log_debug('sending', repr(sanitize(dict(method=method, url=url, verify=self.verify, params=params,
+                                                     timeout=self.timeout, json=json, headers=headers))))
+        try:
+            response = requests.request(method, url, headers=headers, timeout=self.timeout, json=json)
+            content = response.content  # for debug purposes
+            status_code = response.status_code
+            # If the response was successful, no Exception will be raised
+            response.raise_for_status()
+            json_dict, json_error = get_json(response)
+        except requests.exceptions.HTTPError as err:
+            __, json_error = get_json(response)
+            if json_error is None:
+                self.log_error(status_code, 'HTTP error: %s' % err)
+                error_details = str(err)
+            # If an error was reported in the json payload, it is handled below
+        except requests.exceptions.ConnectionError as err:
+            self.log_error(status_code, 'Connection error: %s' % err)
+            error_details = str(err)
+        except Exception as err:
+            self.log_error(status_code, 'Other error: %s' % err)
+            error_details = 'general exception: %s' % str(err)
+        if json_error is not None:
+            self.log_error(status_code, 'Endpoint error: %d: %s' % (status_code, json_error))
+            error_details = json_error
+        self.log_debug(status_code, content)
+        return json_dict, error_details
+
+    def get(self, api, params=None):
+        method = 'GET'
+        return self.send_request(method, api, params)
+
+    def post(self, api, data, params=None):
+        method = 'POST'
+        return self.send_request(method, api, params, json=data)
+
+    def patch(self, api, data, params=None):
+        method = 'PATCH'
+        return self.send_request(method, api, params, json=data)
+
+    def put(self, api, data, params=None):
+        method = 'PUT'
+        return self.send_request(method, api, params, json=data)
+
+    def delete(self, api, data, params=None):
+        method = 'DELETE'
+        return self.send_request(method, api, params, json=data)
+
+    def get_state(self, job_id):
+        """ Method to get the state of the job """
+        response, dummy = self.get('Jobs/%s' % job_id)
+        while str(response['state']) == 'ongoing':
+            time.sleep(15)
+            response, dummy = self.get('Jobs/%s' % job_id)
+        return str(response['state'])
+
+    def log_error(self, status_code, message):
+        LOG.error("%s: %s", status_code, message)
+        self.errors.append(message)
+        self.debug_logs.append((status_code, message))
+
+    def log_debug(self, status_code, content):
+        LOG.debug("%s: %s", status_code, content)
+        self.debug_logs.append((status_code, content))

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/module_utils/netapp_module.py

@@ -0,0 +1,142 @@
+# This code is part of Ansible, but is an independent component.
+# This particular file snippet, and this file snippet only, is BSD licensed.
+# Modules you write using this snippet, which is embedded dynamically by Ansible
+# still belong to the author of the module, and may assign their own license
+# to the complete work.
+#
+# Copyright (c) 2018, Laurent Nicolas <laurentn@netapp.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+#    * Redistributions of source code must retain the above copyright
+#      notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above copyright notice,
+#      this list of conditions and the following disclaimer in the documentation
+#      and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+''' Support class for NetApp ansible modules '''
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+
+def cmp(a, b):
+    """
+    Python 3 does not have a cmp function, this will do the cmp.
+    :param a: first object to check
+    :param b: second object to check
+    :return:
+    """
+    # convert to lower case for string comparison.
+    if a is None:
+        return -1
+    if isinstance(a, str) and isinstance(b, str):
+        a = a.lower()
+        b = b.lower()
+    # if list has string element, convert string to lower case.
+    if isinstance(a, list) and isinstance(b, list):
+        a = [x.lower() if isinstance(x, str) else x for x in a]
+        b = [x.lower() if isinstance(x, str) else x for x in b]
+        a.sort()
+        b.sort()
+    return (a > b) - (a < b)
+
+
+class NetAppModule(object):
+    '''
+    Common class for NetApp modules
+    set of support functions to derive actions based
+    on the current state of the system, and a desired state
+    '''
+
+    def __init__(self):
+        self.log = list()
+        self.changed = False
+        self.parameters = {'name': 'not intialized'}
+
+    def set_parameters(self, ansible_params):
+        self.parameters = dict()
+        for param in ansible_params:
+            if ansible_params[param] is not None:
+                self.parameters[param] = ansible_params[param]
+        return self.parameters
+
+    def get_cd_action(self, current, desired):
+        ''' takes a desired state and a current state, and return an action:
+            create, delete, None
+            eg:
+            is_present = 'absent'
+            some_object = self.get_object(source)
+            if some_object is not None:
+                is_present = 'present'
+            action = cd_action(current=is_present, desired = self.desired.state())
+        '''
+        if 'state' in desired:
+            desired_state = desired['state']
+        else:
+            desired_state = 'present'
+
+        if current is None and desired_state == 'absent':
+            return None
+        if current is not None and desired_state == 'present':
+            return None
+        # change in state
+        self.changed = True
+        if current is not None:
+            return 'delete'
+        return 'create'
+
+    def compare_and_update_values(self, current, desired, keys_to_compare):
+        updated_values = dict()
+        is_changed = False
+        for key in keys_to_compare:
+            if key in current:
+                if key in desired and desired[key] is not None:
+                    if current[key] != desired[key]:
+                        updated_values[key] = desired[key]
+                        is_changed = True
+                    else:
+                        updated_values[key] = current[key]
+                else:
+                    updated_values[key] = current[key]
+
+        return updated_values, is_changed
+
+    def is_rename_action(self, source, target):
+        ''' takes a source and target object, and returns True
+            if a rename is required
+            eg:
+            source = self.get_object(source_name)
+            target = self.get_object(target_name)
+            action = is_rename_action(source, target)
+            :return: None for error, True for rename action, False otherwise
+        '''
+        if source is None and target is None:
+            # error, do nothing
+            # cannot rename an non existent resource
+            # alternatively we could create B
+            return None
+        if source is not None and target is not None:
+            # error, do nothing
+            # idempotency (or) new_name_is_already_in_use
+            # alternatively we could delete B and rename A to B
+            return False
+        if source is None and target is not None:
+            # do nothing, maybe the rename was already done
+            return False
+        # source is not None and target is None:
+        # rename is in order
+        self.changed = True
+        return True

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/modules/aws_netapp_cvs_active_directory.py

@@ -0,0 +1,276 @@
+#!/usr/bin/python
+
+# (c) 2019, NetApp Inc.
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+"""AWS Cloud Volumes Services - Manage ActiveDirectory"""
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'certified'}
+
+
+DOCUMENTATION = '''
+
+module: aws_netapp_cvs_active_directory
+
+short_description: NetApp AWS CloudVolumes Service Manage Active Directory.
+extends_documentation_fragment:
+    - netapp.aws.netapp.awscvs
+version_added: 2.9.0
+author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
+description:
+    - Create, Update, Delete ActiveDirectory on AWS Cloud Volumes Service.
+
+options:
+  state:
+     description:
+         - Whether the specified ActiveDirectory should exist or not.
+     choices: ['present', 'absent']
+     required: true
+     type: str
+
+  region:
+    description:
+    - The region to which the Active Directory credentials are associated.
+    required: true
+    type: str
+
+  domain:
+    description:
+    - Name of the Active Directory domain
+    type: str
+
+  DNS:
+    description:
+    - DNS server address for the Active Directory domain
+    - Required when C(state=present)
+    - Required when C(state=present), to modify ActiveDirectory properties.
+    type: str
+
+  netBIOS:
+    description:
+    - NetBIOS name of the server.
+    type: str
+
+  username:
+    description:
+    - Username of the Active Directory domain administrator
+    type: str
+
+  password:
+    description:
+    - Password of the Active Directory domain administrator
+    - Required when C(state=present), to modify ActiveDirectory properties
+    type: str
+'''
+
+EXAMPLES = """
+    - name: Create Active Directory
+      aws_netapp_cvs_active_directory.py:
+        state: present
+        region: us-east-1
+        DNS: 101.102.103.123
+        domain: mydomain.com
+        password: netapp1!
+        netBIOS: testing
+        username: user1
+        api_url : My_CVS_Hostname
+        api_key: My_API_Key
+        secret_key : My_Secret_Key
+
+    - name: Update Active Directory
+      aws_netapp_cvs_active_directory.py:
+        state: present
+        region: us-east-1
+        DNS: 101.102.103.123
+        domain: mydomain.com
+        password: netapp2!
+        netBIOS: testingBIOS
+        username: user2
+        api_url : My_CVS_Hostname
+        api_key: My_API_Key
+        secret_key : My_Secret_Key
+
+    - name: Delete Active Directory
+      aws_netapp_cvs_active_directory.py:
+        state: absent
+        region: us-east-1
+        domain: mydomain.com
+        api_url : My_CVS_Hostname
+        api_key: My_API_Key
+        secret_key : My_Secret_Key
+"""
+
+RETURN = '''
+'''
+
+from ansible.module_utils.basic import AnsibleModule
+import ansible_collections.netapp.aws.plugins.module_utils.netapp as netapp_utils
+from ansible_collections.netapp.aws.plugins.module_utils.netapp_module import NetAppModule
+from ansible_collections.netapp.aws.plugins.module_utils.netapp import AwsCvsRestAPI
+
+
+class AwsCvsNetappActiveDir(object):
+    """
+    Contains methods to parse arguments,
+    derive details of AWS_CVS objects
+    and send requests to AWS CVS via
+    the restApi
+    """
+
+    def __init__(self):
+        """
+        Parse arguments, setup state variables,
+        check paramenters and ensure request module is installed
+        """
+        self.argument_spec = netapp_utils.aws_cvs_host_argument_spec()
+        self.argument_spec.update(dict(
+            state=dict(required=True, choices=['present', 'absent'], type='str'),
+            region=dict(required=True, type='str'),
+            DNS=dict(required=False, type='str'),
+            domain=dict(required=False, type='str'),
+            password=dict(required=False, type='str', no_log=True),
+            netBIOS=dict(required=False, type='str'),
+            username=dict(required=False, type='str')
+        ))
+
+        self.module = AnsibleModule(
+            argument_spec=self.argument_spec,
+            required_if=[
+                ('state', 'present', ['domain', 'password']),
+            ],
+            supports_check_mode=True
+        )
+
+        self.na_helper = NetAppModule()
+
+        # set up state variables
+        self.parameters = self.na_helper.set_parameters(self.module.params)
+        # Calling generic AWSCVS restApi class
+        self.rest_api = AwsCvsRestAPI(self.module)
+
+    def get_activedirectory_id(self):
+        # Check if  ActiveDirectory exists
+        # Return UUID for ActiveDirectory is found, None otherwise
+        try:
+            list_activedirectory, error = self.rest_api.get('Storage/ActiveDirectory')
+        except Exception:
+            return None
+        if error is not None:
+            self.module.fail_json(msg='Error calling list_activedirectory: %s' % error)
+
+        for activedirectory in list_activedirectory:
+            if activedirectory['region'] == self.parameters['region']:
+                return activedirectory['UUID']
+        return None
+
+    def get_activedirectory(self, activedirectory_id=None):
+        if activedirectory_id is None:
+            return None
+        else:
+            activedirectory_info, error = self.rest_api.get('Storage/ActiveDirectory/%s' % activedirectory_id)
+            if not error:
+                return activedirectory_info
+            return None
+
+    def create_activedirectory(self):
+        # Create ActiveDirectory
+        api = 'Storage/ActiveDirectory'
+        data = {"region": self.parameters['region'], "DNS": self.parameters['DNS'], "domain": self.parameters['domain'],
+                "username": self.parameters['username'], "password": self.parameters['password'], "netBIOS": self.parameters['netBIOS']}
+
+        response, error = self.rest_api.post(api, data)
+
+        if not error:
+            return response
+        else:
+            self.module.fail_json(msg=response['message'])
+
+    def delete_activedirectory(self):
+        activedirectory_id = self.get_activedirectory_id()
+        # Delete ActiveDirectory
+
+        if activedirectory_id:
+            api = 'Storage/ActiveDirectory/' + activedirectory_id
+            data = None
+            response, error = self.rest_api.delete(api, data)
+            if not error:
+                return response
+            else:
+                self.module.fail_json(msg=response['message'])
+
+        else:
+            self.module.fail_json(msg="Active Directory does not exist")
+
+    def update_activedirectory(self, activedirectory_id, updated_activedirectory):
+        # Update ActiveDirectory
+        api = 'Storage/ActiveDirectory/' + activedirectory_id
+        data = {
+            "region": self.parameters['region'],
+            "DNS": updated_activedirectory['DNS'],
+            "domain": updated_activedirectory['domain'],
+            "username": updated_activedirectory['username'],
+            "password": updated_activedirectory['password'],
+            "netBIOS": updated_activedirectory['netBIOS']
+        }
+
+        response, error = self.rest_api.put(api, data)
+        if not error:
+            return response
+        else:
+            self.module.fail_json(msg=response['message'])
+
+    def apply(self):
+        """
+        Perform pre-checks, call functions and exit
+        """
+        modify = False
+        activedirectory_id = self.get_activedirectory_id()
+        current = self.get_activedirectory(activedirectory_id)
+        cd_action = self.na_helper.get_cd_action(current, self.parameters)
+
+        if current and self.parameters['state'] != 'absent':
+            keys_to_check = ['DNS', 'domain', 'username', 'netBIOS']
+            updated_active_directory, modify = self.na_helper.compare_and_update_values(current, self.parameters, keys_to_check)
+
+            if self.parameters['password']:
+                modify = True
+                updated_active_directory['password'] = self.parameters['password']
+
+            if modify is True:
+                self.na_helper.changed = True
+                if 'domain' in self.parameters and self.parameters['domain'] is not None:
+                    ad_exists = self.get_activedirectory(updated_active_directory['domain'])
+                    if ad_exists:
+                        modify = False
+                        self.na_helper.changed = False
+
+        if self.na_helper.changed:
+            if self.module.check_mode:
+                pass
+            else:
+                if modify is True:
+                    self.update_activedirectory(activedirectory_id, updated_active_directory)
+                elif cd_action == 'create':
+                    self.create_activedirectory()
+                elif cd_action == 'delete':
+                    self.delete_activedirectory()
+
+        self.module.exit_json(changed=self.na_helper.changed)
+
+
+def main():
+    """
+    Main function
+    """
+    aws_netapp_cvs_active_directory = AwsCvsNetappActiveDir()
+    aws_netapp_cvs_active_directory.apply()
+
+
+if __name__ == '__main__':
+    main()

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/modules/aws_netapp_cvs_filesystems.py

@@ -0,0 +1,362 @@
+#!/usr/bin/python
+
+# (c) 2019, NetApp Inc
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+"""AWS Cloud Volumes Services - Manage fileSystem"""
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+
+DOCUMENTATION = '''
+
+module: aws_netapp_cvs_filesystems
+
+short_description: NetApp AWS Cloud Volumes Service Manage FileSystem.
+extends_documentation_fragment:
+    - netapp.aws.netapp.awscvs
+version_added: 2.9.0
+author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
+description:
+- Create, Update, Delete fileSystem on AWS Cloud Volumes Service.
+
+options:
+  state:
+    description:
+    - Whether the specified fileSystem should exist or not.
+    required: true
+    choices: ['present', 'absent']
+    type: str
+
+  region:
+    description:
+    - The region to which the filesystem belongs to.
+    required: true
+    type: str
+
+  creationToken:
+    description:
+    - Name of the filesystem
+    required: true
+    type: str
+
+  quotaInBytes:
+    description:
+    - Size of the filesystem
+    - Required for create
+    type: int
+
+  serviceLevel:
+    description:
+    - Service Level of a filesystem.
+    choices: ['standard', 'premium', 'extreme']
+    type: str
+
+  exportPolicy:
+    description:
+    - The policy rules to export the filesystem
+    type: dict
+    suboptions:
+        rules:
+            description:
+            - Set of rules to export the filesystem
+            - Requires allowedClients, access and protocol
+            type: list
+            elements: dict
+            suboptions:
+                allowedClients:
+                  description:
+                  - Comma separated list of ip address blocks of the clients to access the fileSystem
+                  - Each address block contains the starting IP address and size for the block
+                  type: str
+
+                cifs:
+                  description:
+                  - Enable or disable cifs filesystem
+                  type: bool
+
+                nfsv3:
+                  description:
+                  - Enable or disable nfsv3 fileSystem
+                  type: bool
+
+                nfsv4:
+                  description:
+                  - Enable or disable nfsv4 filesystem
+                  type: bool
+
+                ruleIndex:
+                  description:
+                  - Index number of the rule
+                  type: int
+
+                unixReadOnly:
+                  description:
+                  - Should fileSystem have read only permission or not
+                  type: bool
+
+                unixReadWrite:
+                  description:
+                  - Should fileSystem have read write permission or not
+                  type: bool
+'''
+
+EXAMPLES = """
+- name: Create FileSystem
+  aws_netapp_cvs_filesystems:
+    state: present
+    region: us-east-1
+    creationToken: newVolume-1
+    exportPolicy:
+        rules:
+          - allowedClients: 172.16.0.4
+            cifs: False
+            nfsv3: True
+            nfsv4: True
+            ruleIndex: 1
+            unixReadOnly: True
+            unixReadWrite: False
+    quotaInBytes: 100000000000
+    api_url : cds-aws-bundles.netapp.com:8080
+    api_key: My_API_Key
+    secret_key : My_Secret_Key
+
+- name: Update FileSystem
+  aws_netapp_cvs_filesystems:
+     state: present
+     region: us-east-1
+     creationToken: newVolume-1
+     exportPolicy:
+         rules:
+           - allowedClients: 172.16.0.4
+             cifs: False
+             nfsv3: True
+             nfsv4: True
+             ruleIndex: 1
+             unixReadOnly: True
+             unixReadWrite: False
+     quotaInBytes: 200000000000
+     api_url : cds-aws-bundles.netapp.com:8080
+     api_key: My_API_Key
+     secret_key : My_Secret_Key
+
+- name: Delete FileSystem
+  aws_netapp_cvs_filesystems:
+     state: present
+     region: us-east-1
+     creationToken: newVolume-1
+     quotaInBytes: 100000000000
+     api_url : cds-aws-bundles.netapp.com:8080
+     api_key: My_API_Key
+     secret_key : My_Secret_Key
+"""
+
+RETURN = """
+"""
+
+from ansible.module_utils.basic import AnsibleModule
+import ansible_collections.netapp.aws.plugins.module_utils.netapp as netapp_utils
+from ansible_collections.netapp.aws.plugins.module_utils.netapp_module import NetAppModule
+from ansible_collections.netapp.aws.plugins.module_utils.netapp import AwsCvsRestAPI
+
+
+class AwsCvsNetappFileSystem(object):
+    """
+    Contains methods to parse arguments,
+    derive details of AWS_CVS objects
+    and send requests to AWS CVS via
+    the restApi
+    """
+
+    def __init__(self):
+        """
+        Parse arguments, setup state variables,
+        check paramenters and ensure request module is installed
+        """
+        self.argument_spec = netapp_utils.aws_cvs_host_argument_spec()
+        self.argument_spec.update(dict(
+            state=dict(required=True, choices=['present', 'absent']),
+            region=dict(required=True, type='str'),
+            creationToken=dict(required=True, type='str', no_log=False),
+            quotaInBytes=dict(required=False, type='int'),
+            serviceLevel=dict(required=False, choices=['standard', 'premium', 'extreme']),
+            exportPolicy=dict(
+                type='dict',
+                options=dict(
+                    rules=dict(
+                        type='list',
+                        elements='dict',
+                        options=dict(
+                            allowedClients=dict(required=False, type='str'),
+                            cifs=dict(required=False, type='bool'),
+                            nfsv3=dict(required=False, type='bool'),
+                            nfsv4=dict(required=False, type='bool'),
+                            ruleIndex=dict(required=False, type='int'),
+                            unixReadOnly=dict(required=False, type='bool'),
+                            unixReadWrite=dict(required=False, type='bool')
+                        )
+                    )
+                )
+            ),
+        ))
+
+        self.module = AnsibleModule(
+            argument_spec=self.argument_spec,
+            required_if=[
+                ('state', 'present', ['region', 'creationToken', 'quotaInBytes']),
+            ],
+            supports_check_mode=True
+        )
+
+        self.na_helper = NetAppModule()
+
+        # set up state variables
+        self.parameters = self.na_helper.set_parameters(self.module.params)
+
+        # Calling generic AWSCVS restApi class
+        self.rest_api = AwsCvsRestAPI(self.module)
+
+        self.data = {}
+        for key in self.parameters.keys():
+            self.data[key] = self.parameters[key]
+
+    def get_filesystem_id(self):
+        # Check given FileSystem is exists
+        # Return fileSystemId is found, None otherwise
+        list_filesystem, error = self.rest_api.get('FileSystems')
+        if error:
+            self.module.fail_json(msg=error)
+
+        for filesystem in list_filesystem:
+            if filesystem['creationToken'] == self.parameters['creationToken']:
+                return filesystem['fileSystemId']
+        return None
+
+    def get_filesystem(self, filesystem_id):
+        # Get FileSystem information by fileSystemId
+        # Return fileSystem Information
+        filesystem_info, error = self.rest_api.get('FileSystems/%s' % filesystem_id)
+        if error:
+            self.module.fail_json(msg=error)
+        else:
+            return filesystem_info
+        return None
+
+    def is_job_done(self, response):
+        # check jobId is present and equal to 'done'
+        # return True on success, False otherwise
+        try:
+            job_id = response['jobs'][0]['jobId']
+        except TypeError:
+            job_id = None
+
+        if job_id is not None and self.rest_api.get_state(job_id) == 'done':
+            return True
+        return False
+
+    def create_filesystem(self):
+        # Create fileSystem
+        api = 'FileSystems'
+        response, error = self.rest_api.post(api, self.data)
+        if not error:
+            if self.is_job_done(response):
+                return
+            error = "Error: unexpected response on FileSystems create: %s" % str(response)
+        self.module.fail_json(msg=error)
+
+    def delete_filesystem(self, filesystem_id):
+        # Delete FileSystem
+        api = 'FileSystems/' + filesystem_id
+        self.data = None
+        response, error = self.rest_api.delete(api, self.data)
+        if not error:
+            if self.is_job_done(response):
+                return
+            error = "Error: unexpected response on FileSystems delete: %s" % str(response)
+        self.module.fail_json(msg=error)
+
+    def update_filesystem(self, filesystem_id):
+        # Update FileSystem
+        api = 'FileSystems/' + filesystem_id
+        response, error = self.rest_api.put(api, self.data)
+        if not error:
+            if self.is_job_done(response):
+                return
+            error = "Error: unexpected response on FileSystems update: %s" % str(response)
+        self.module.fail_json(msg=error)
+
+    def apply(self):
+        """
+        Perform pre-checks, call functions and exit
+        """
+
+        filesystem = None
+        filesystem_id = self.get_filesystem_id()
+
+        if filesystem_id:
+            # Getting the FileSystem details
+            filesystem = self.get_filesystem(filesystem_id)
+
+        cd_action = self.na_helper.get_cd_action(filesystem, self.parameters)
+
+        if cd_action is None and self.parameters['state'] == 'present':
+            # Check if we need to update the fileSystem
+            update_filesystem = False
+            if filesystem['quotaInBytes'] is not None and 'quotaInBytes' in self.parameters \
+                    and filesystem['quotaInBytes'] != self.parameters['quotaInBytes']:
+                update_filesystem = True
+            elif filesystem['creationToken'] is not None and 'creationToken' in self.parameters \
+                    and filesystem['creationToken'] != self.parameters['creationToken']:
+                update_filesystem = True
+            elif filesystem['serviceLevel'] is not None and 'serviceLevel' in self.parameters \
+                    and filesystem['serviceLevel'] != self.parameters['serviceLevel']:
+                update_filesystem = True
+            elif 'exportPolicy' in filesystem and filesystem['exportPolicy']['rules'] is not None and 'exportPolicy' in self.parameters:
+                for rule_org in filesystem['exportPolicy']['rules']:
+                    for rule in self.parameters['exportPolicy']['rules']:
+                        if rule_org['allowedClients'] != rule['allowedClients']:
+                            update_filesystem = True
+                        elif rule_org['unixReadOnly'] != rule['unixReadOnly']:
+                            update_filesystem = True
+                        elif rule_org['unixReadWrite'] != rule['unixReadWrite']:
+                            update_filesystem = True
+
+            if update_filesystem:
+                self.na_helper.changed = True
+
+        result_message = ""
+
+        if self.na_helper.changed:
+            if self.module.check_mode:
+                # Skip changes
+                result_message = "Check mode, skipping changes"
+            else:
+                if cd_action == "create":
+                    self.create_filesystem()
+                    result_message = "FileSystem Created"
+                elif cd_action == "delete":
+                    self.delete_filesystem(filesystem_id)
+                    result_message = "FileSystem Deleted"
+                else:   # modify
+                    self.update_filesystem(filesystem_id)
+                    result_message = "FileSystem Updated"
+        self.module.exit_json(changed=self.na_helper.changed, msg=result_message)
+
+
+def main():
+    """
+    Main function
+    """
+    aws_cvs_netapp_filesystem = AwsCvsNetappFileSystem()
+    aws_cvs_netapp_filesystem.apply()
+
+
+if __name__ == '__main__':
+    main()

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/modules/aws_netapp_cvs_pool.py

@@ -0,0 +1,267 @@
+#!/usr/bin/python
+
+# (c) 2019, NetApp Inc.
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+"""AWS Cloud Volumes Services - Manage Pools"""
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+
+DOCUMENTATION = '''
+
+module: aws_netapp_cvs_pool
+
+short_description: NetApp AWS Cloud Volumes Service Manage Pools.
+extends_documentation_fragment:
+    - netapp.aws.netapp.awscvs
+version_added: 2.9.0
+author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
+description:
+    - Create, Update, Delete Pool on AWS Cloud Volumes Service.
+
+options:
+    state:
+        description:
+        - Whether the specified pool should exist or not.
+        choices: ['present', 'absent']
+        required: true
+        type: str
+    region:
+        description:
+        - The region to which the Pool is associated.
+        required: true
+        type: str
+    name:
+        description:
+        - pool name ( The human readable name of the Pool )
+        - name can be used for create, update and delete operations
+        required: true
+        type: str
+    serviceLevel:
+        description:
+        - The service level of the Pool
+        - can be used with pool create, update operations
+        choices: ['basic', 'standard', 'extreme']
+        type: str
+    sizeInBytes:
+        description:
+        - Size of the Pool in bytes
+        - can be used with pool create, update operations
+        - minimum value is 4000000000000 bytes
+        type: int
+    vendorID:
+        description:
+        - A vendor ID for the Pool. E.g. an ID allocated by a vendor service for the Pool.
+        - can be used with pool create, update operations
+        - must be unique
+        type: str
+    from_name:
+        description:
+        - rename the existing pool name ( The human readable name of the Pool )
+        - I(from_name) is the existing name, and I(name) the new name
+        - can be used with update operation
+        type: str
+'''
+
+EXAMPLES = """
+- name: Create a new Pool
+  aws_netapp_cvs_pool:
+    state: present
+    name: TestPoolBB12
+    serviceLevel: extreme
+    sizeInBytes: 4000000000000
+    vendorID: ansiblePoolTestVendorBB12
+    region: us-east-1
+    api_url: cds-aws-bundles.netapp.com
+    api_key: MyAPiKey
+    secret_key: MySecretKey
+
+- name: Delete a Pool
+  aws_netapp_cvs_pool:
+    state: absent
+    name: TestPoolBB7
+    region: us-east-1
+    api_url: cds-aws-bundles.netapp.com
+    api_key: MyAPiKey
+    secret_key: MySecretKey
+
+- name: Update a Pool
+  aws_netapp_cvs_pool:
+    state: present
+    from_name: TestPoolBB12
+    name: Mynewpool7
+    vendorID: ansibleVendorMynewpool15
+    serviceLevel: extreme
+    sizeInBytes: 4000000000000
+    region: us-east-1
+    api_url: cds-aws-bundles.netapp.com
+    api_key: MyAPiKey
+    secret_key: MySecretKey
+
+"""
+
+RETURN = '''
+'''
+
+from ansible.module_utils.basic import AnsibleModule
+import ansible_collections.netapp.aws.plugins.module_utils.netapp as netapp_utils
+from ansible_collections.netapp.aws.plugins.module_utils.netapp_module import NetAppModule
+from ansible_collections.netapp.aws.plugins.module_utils.netapp import AwsCvsRestAPI
+
+
+class NetAppAWSCVS(object):
+    '''Class  for  Pool operations '''
+
+    def __init__(self):
+        """
+        Parse arguments, setup state variables,
+        """
+        self.argument_spec = netapp_utils.aws_cvs_host_argument_spec()
+        self.argument_spec.update(dict(
+            state=dict(required=True, choices=['present', 'absent']),
+            region=dict(required=True, type='str'),
+            name=dict(required=True, type='str'),
+            from_name=dict(required=False, type='str'),
+            serviceLevel=dict(required=False, choices=['basic', 'standard', 'extreme'], type='str'),
+            sizeInBytes=dict(required=False, type='int'),
+            vendorID=dict(required=False, type='str'),
+        ))
+        self.module = AnsibleModule(
+            argument_spec=self.argument_spec,
+            supports_check_mode=True
+        )
+
+        self.na_helper = NetAppModule()
+        self.parameters = self.na_helper.set_parameters(self.module.params)
+        self.rest_api = AwsCvsRestAPI(self.module)
+        self.sizeinbytes_min_value = 4000000000000
+
+    def get_aws_netapp_cvs_pool(self, name=None):
+        """
+        Returns Pool object if exists else Return None
+        """
+        pool_info = None
+
+        if name is None:
+            name = self.parameters['name']
+
+        pools, error = self.rest_api.get('Pools')
+
+        if error is None and pools is not None:
+            for pool in pools:
+                if 'name' in pool and pool['region'] == self.parameters['region']:
+                    if pool['name'] == name:
+                        pool_info = pool
+                        break
+
+        return pool_info
+
+    def create_aws_netapp_cvs_pool(self):
+        """
+        Create a pool
+        """
+        api = 'Pools'
+
+        for key in ['serviceLevel', 'sizeInBytes', 'vendorID']:
+            if key not in self.parameters.keys() or self.parameters[key] is None:
+                self.module.fail_json(changed=False, msg="Mandatory key '%s' required" % (key))
+
+        pool = {
+            "name": self.parameters['name'],
+            "region": self.parameters['region'],
+            "serviceLevel": self.parameters['serviceLevel'],
+            "sizeInBytes": self.parameters['sizeInBytes'],
+            "vendorID": self.parameters['vendorID']
+        }
+
+        dummy, error = self.rest_api.post(api, pool)
+        if error is not None:
+            self.module.fail_json(changed=False, msg=error)
+
+    def update_aws_netapp_cvs_pool(self, update_pool_info, pool_id):
+        """
+        Update a pool
+        """
+        api = 'Pools/' + pool_id
+
+        pool = {
+            "name": update_pool_info['name'],
+            "region": self.parameters['region'],
+            "serviceLevel": update_pool_info['serviceLevel'],
+            "sizeInBytes": update_pool_info['sizeInBytes'],
+            "vendorID": update_pool_info['vendorID']
+        }
+
+        dummy, error = self.rest_api.put(api, pool)
+        if error is not None:
+            self.module.fail_json(changed=False, msg=error)
+
+    def delete_aws_netapp_cvs_pool(self, pool_id):
+        """
+        Delete a pool
+        """
+        api = 'Pools/' + pool_id
+        data = None
+        dummy, error = self.rest_api.delete(api, data)
+
+        if error is not None:
+            self.module.fail_json(changed=False, msg=error)
+
+    def apply(self):
+        """
+        Perform pre-checks, call functions and exit
+        """
+        update_required = False
+        cd_action = None
+
+        if 'sizeInBytes' in self.parameters.keys() and self.parameters['sizeInBytes'] < self.sizeinbytes_min_value:
+            self.module.fail_json(changed=False, msg="sizeInBytes should be greater than  or equal to %d" % (self.sizeinbytes_min_value))
+
+        current = self.get_aws_netapp_cvs_pool()
+        if self.parameters.get('from_name'):
+            existing = self.get_aws_netapp_cvs_pool(self.parameters['from_name'])
+            rename = self.na_helper.is_rename_action(existing, current)
+            if rename is None:
+                self.module.fail_json(changed=False, msg="unable to rename pool: '%s' does not exist" % self.parameters['from_name'])
+            if rename:
+                current = existing
+        else:
+            cd_action = self.na_helper.get_cd_action(current, self.parameters)
+
+        if cd_action is None and self.parameters['state'] == 'present':
+            keys_to_check = ['name', 'vendorID', 'sizeInBytes', 'serviceLevel']
+            update_pool_info, update_required = self.na_helper.compare_and_update_values(current, self.parameters, keys_to_check)
+
+            if update_required is True:
+                self.na_helper.changed = True
+                cd_action = 'update'
+
+        if self.na_helper.changed:
+            if self.module.check_mode:
+                pass
+            else:
+                if cd_action == 'update':
+                    self.update_aws_netapp_cvs_pool(update_pool_info, current['poolId'])
+                elif cd_action == 'create':
+                    self.create_aws_netapp_cvs_pool()
+                elif cd_action == 'delete':
+                    self.delete_aws_netapp_cvs_pool(current['poolId'])
+
+        self.module.exit_json(changed=self.na_helper.changed)
+
+
+def main():
+    '''Main Function'''
+    aws_cvs_netapp_pool = NetAppAWSCVS()
+    aws_cvs_netapp_pool.apply()
+
+
+if __name__ == '__main__':
+    main()

lib/python3.10/site-packages/ansible_collections/netapp/aws/plugins/modules/aws_netapp_cvs_snapshots.py

@@ -0,0 +1,245 @@
+#!/usr/bin/python
+
+# (c) 2019, NetApp Inc
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+"""AWS Cloud Volumes Services - Manage Snapshots"""
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+
+ANSIBLE_METADATA = {'metadata_version': '1.1',
+                    'status': ['preview'],
+                    'supported_by': 'community'}
+
+
+DOCUMENTATION = '''
+
+module: aws_netapp_cvs_snapshots
+
+short_description: NetApp AWS Cloud Volumes Service Manage Snapshots.
+extends_documentation_fragment:
+    - netapp.aws.netapp.awscvs
+version_added: 2.9.0
+author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
+description:
+- Create, Update, Delete Snapshot on AWS Cloud Volumes Service.
+
+options:
+  state:
+     description:
+     - Whether the specified snapshot should exist or not.
+     required: true
+     type: str
+     choices: ['present', 'absent']
+
+  region:
+    description:
+    - The region to which the snapshot belongs to.
+    required: true
+    type: str
+
+  name:
+    description:
+    - Name of the snapshot
+    required: true
+    type: str
+
+  fileSystemId:
+    description:
+    - Name or Id of the filesystem.
+    - Required for create operation
+    type: str
+
+  from_name:
+    description:
+    - ID or Name of the snapshot to rename.
+    - Required to create an snapshot called 'name' by renaming 'from_name'.
+    type: str
+'''
+
+EXAMPLES = """
+- name: Create Snapshot
+  aws_netapp_cvs_snapshots:
+    state: present
+    region: us-east-1
+    name: testSnapshot
+    fileSystemId: testVolume
+    api_url : cds-aws-bundles.netapp.com
+    api_key: myApiKey
+    secret_key : mySecretKey
+
+- name: Update Snapshot
+  aws_netapp_cvs_snapshots:
+    state: present
+    region: us-east-1
+    name: testSnapshot - renamed
+    from_name: testSnapshot
+    fileSystemId: testVolume
+    api_url : cds-aws-bundles.netapp.com
+    api_key: myApiKey
+    secret_key : mySecretKey
+
+- name: Delete Snapshot
+  aws_netapp_cvs_snapshots:
+    state: absent
+    region: us-east-1
+    name: testSnapshot
+    api_url : cds-aws-bundles.netapp.com
+    api_key: myApiKey
+    secret_key : mySecretKey
+"""
+
+RETURN = """
+"""
+
+from ansible.module_utils.basic import AnsibleModule
+import ansible_collections.netapp.aws.plugins.module_utils.netapp as netapp_utils
+from ansible_collections.netapp.aws.plugins.module_utils.netapp_module import NetAppModule
+from ansible_collections.netapp.aws.plugins.module_utils.netapp import AwsCvsRestAPI
+
+
+class AwsCvsNetappSnapshot(object):
+    """
+    Contains methods to parse arguments,
+    derive details of AWS_CVS objects
+    and send requests to AWS CVS via
+    the restApi
+    """
+
+    def __init__(self):
+        """
+        Parse arguments, setup state variables,
+        check paramenters and ensure request module is installed
+        """
+        self.argument_spec = netapp_utils.aws_cvs_host_argument_spec()
+        self.argument_spec.update(dict(
+            state=dict(required=True, choices=['present', 'absent']),
+            region=dict(required=True, type='str'),
+            name=dict(required=True, type='str'),
+            from_name=dict(required=False, type='str'),
+            fileSystemId=dict(required=False, type='str')
+        ))
+
+        self.module = AnsibleModule(
+            argument_spec=self.argument_spec,
+            required_if=[
+                ('state', 'present', ['fileSystemId']),
+            ],
+            supports_check_mode=True
+        )
+
+        self.na_helper = NetAppModule()
+
+        # set up state variables
+        self.parameters = self.na_helper.set_parameters(self.module.params)
+        # Calling generic AWSCVS restApi class
+        self.rest_api = AwsCvsRestAPI(self.module)
+
+        # Checking for the parameters passed and create new parameters list
+        self.data = {}
+        for key in self.parameters.keys():
+            self.data[key] = self.parameters[key]
+
+    def get_snapshot_id(self, name):
+        # Check if  snapshot exists
+        # Return snpashot Id  If Snapshot is found, None otherwise
+        list_snapshots, error = self.rest_api.get('Snapshots')
+
+        if error:
+            self.module.fail_json(msg=error)
+
+        for snapshot in list_snapshots:
+            if snapshot['name'] == name:
+                return snapshot['snapshotId']
+        return None
+
+    def get_filesystem_id(self):
+        # Check given FileSystem is exists
+        # Return fileSystemId is found, None otherwise
+        list_filesystem, error = self.rest_api.get('FileSystems')
+
+        if error:
+            self.module.fail_json(msg=error)
+        for filesystem in list_filesystem:
+            if filesystem['fileSystemId'] == self.parameters['fileSystemId']:
+                return filesystem['fileSystemId']
+            elif filesystem['creationToken'] == self.parameters['fileSystemId']:
+                return filesystem['fileSystemId']
+        return None
+
+    def create_snapshot(self):
+        # Create Snapshot
+        api = 'Snapshots'
+        dummy, error = self.rest_api.post(api, self.data)
+        if error:
+            self.module.fail_json(msg=error)
+
+    def rename_snapshot(self, snapshot_id):
+        # Rename Snapshot
+        api = 'Snapshots/' + snapshot_id
+        dummy, error = self.rest_api.put(api, self.data)
+        if error:
+            self.module.fail_json(msg=error)
+
+    def delete_snapshot(self, snapshot_id):
+        # Delete Snapshot
+        api = 'Snapshots/' + snapshot_id
+        dummy, error = self.rest_api.delete(api, self.data)
+        if error:
+            self.module.fail_json(msg=error)
+
+    def apply(self):
+        """
+        Perform pre-checks, call functions and exit
+        """
+        self.snapshot_id = self.get_snapshot_id(self.data['name'])
+
+        if self.snapshot_id is None and 'fileSystemId' in self.data:
+            self.filesystem_id = self.get_filesystem_id()
+            self.data['fileSystemId'] = self.filesystem_id
+            if self.filesystem_id is None:
+                self.module.fail_json(msg='Error: Specified filesystem id %s does not exist ' % self.data['fileSystemId'])
+
+        cd_action = self.na_helper.get_cd_action(self.snapshot_id, self.data)
+        result_message = ""
+        if self.na_helper.changed:
+            if self.module.check_mode:
+                # Skip changes
+                result_message = "Check mode, skipping changes"
+            else:
+                if cd_action == "delete":
+                    self.delete_snapshot(self.snapshot_id)
+                    result_message = "Snapshot Deleted"
+
+                elif cd_action == "create":
+                    if 'from_name' in self.data:
+                        # If cd_action is craete and from_name is given
+                        snapshot_id = self.get_snapshot_id(self.data['from_name'])
+                        if snapshot_id is not None:
+                            # If resource pointed by from_name exists, rename the snapshot to name
+                            self.rename_snapshot(snapshot_id)
+                            result_message = "Snapshot Updated"
+                        else:
+                            # If resource pointed by from_name does not exists, error out
+                            self.module.fail_json(msg="Resource does not exist : %s" % self.data['from_name'])
+                    else:
+                        self.create_snapshot()
+                        # If from_name is not defined, Create from scratch.
+                        result_message = "Snapshot Created"
+
+        self.module.exit_json(changed=self.na_helper.changed, msg=result_message)
+
+
+def main():
+    """
+    Main function
+    """
+    aws_netapp_cvs_snapshots = AwsCvsNetappSnapshot()
+    aws_netapp_cvs_snapshots.apply()
+
+
+if __name__ == '__main__':
+    main()