Init: mediaserver

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