Adding upstream version 7.7.0+dfsg.upstream/7.7.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1516 insertions, 0 deletions

diff --git a/ansible_collections/dellemc/unity/plugins/modules/consistencygroup.py b/ansible_collections/dellemc/unity/plugins/modules/consistencygroup.py
new file mode 100644
index 000000000..14e4de506
--- /dev/null
+++ b/ansible_collections/dellemc/unity/plugins/modules/consistencygroup.py
@@ -0,0 +1,1516 @@
+#!/usr/bin/python
+# Copyright: (c) 2020, Dell Technologies
+
+# Apache License version 2.0 (see MODULE-LICENSE or http://www.apache.org/licenses/LICENSE-2.0.txt)
+
+"""Ansible module for managing consistency group on Unity"""
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+DOCUMENTATION = r"""
+module: consistencygroup
+version_added: '1.1.0'
+short_description: Manage consistency groups on Unity storage system
+description:
+- Managing the consistency group on the Unity storage system includes
+  creating new consistency group, adding volumes to consistency
+  group, removing volumes from consistency group, mapping hosts to
+  consistency group, unmapping hosts from consistency group,
+  renaming consistency group, modifying attributes of consistency group,
+  enabling replication in consistency group, disabling replication in
+  consistency group and deleting consistency group.
+
+extends_documentation_fragment:
+  - dellemc.unity.unity
+
+author:
+- Akash Shendge (@shenda1) <ansible.team@dell.com>
+
+options:
+  cg_name:
+    description:
+    - The name of the consistency group.
+    - It is mandatory for the create operation.
+    - Specify either I(cg_name) or I(cg_id) (but not both) for any operation.
+    type: str
+  cg_id:
+    description:
+    - The ID of the consistency group.
+    - It can be used only for get, modify, add/remove volumes, or delete
+      operations.
+    type: str
+  volumes:
+    description:
+    - This is a list of volumes.
+    - Either the volume ID or name must be provided for adding/removing
+      existing volumes from consistency group.
+    - If I(volumes) are given, then I(vol_state) should also be specified.
+    - Volumes cannot be added/removed from consistency group, if the
+      consistency group or the volume has snapshots.
+    type: list
+    elements: dict
+    suboptions:
+      vol_id:
+        description:
+        - The ID of the volume.
+        type: str
+      vol_name:
+        description:
+        - The name of the volume.
+        type: str
+  vol_state:
+    description:
+    - String variable, describes the state of volumes inside consistency
+      group.
+    - If I(volumes) are given, then I(vol_state) should also be specified.
+    choices: [present-in-group , absent-in-group]
+    type: str
+  new_cg_name:
+    description:
+     - The new name of the consistency group, used in rename operation.
+    type: str
+  description:
+    description:
+    - Description of the consistency group.
+    type: str
+  snap_schedule:
+    description:
+    - Snapshot schedule assigned to the consistency group.
+    - Specifying an empty string "" removes the existing snapshot schedule
+      from consistency group.
+    type: str
+  tiering_policy:
+    description:
+    - Tiering policy choices for how the storage resource data will be
+      distributed among the tiers available in the pool.
+    choices: ['AUTOTIER_HIGH', 'AUTOTIER', 'HIGHEST', 'LOWEST']
+    type: str
+  hosts:
+    description:
+    - This is a list of hosts.
+    - Either the host ID or name must be provided for mapping/unmapping
+      hosts for a consistency group.
+    - If I(hosts) are given, then I(mapping_state) should also be specified.
+    - Hosts cannot be mapped to a consistency group, if the
+      consistency group has no volumes.
+    - When a consistency group is being mapped to the host,
+      users should not use the volume module to map the volumes
+      in the consistency group to hosts.
+    type: list
+    elements: dict
+    suboptions:
+      host_id:
+        description:
+        - The ID of the host.
+        type: str
+      host_name:
+        description:
+        - The name of the host.
+        type: str
+  mapping_state:
+    description:
+    - String variable, describes the state of hosts inside the consistency
+      group.
+    - If I(hosts) are given, then I(mapping_state) should also be specified.
+    choices: [mapped , unmapped]
+    type: str
+  replication_params:
+    description:
+    - Settings required for enabling replication.
+    type: dict
+    suboptions:
+      destination_cg_name:
+        description:
+        - Name of the destination consistency group.
+        - Default value will be source consistency group name prefixed by 'DR_'.
+        type: str
+      replication_mode:
+        description:
+        - The replication mode.
+        type: str
+        required: true
+        choices: ['asynchronous', 'manual']
+      rpo:
+        description:
+        - Maximum time to wait before the system syncs the source and destination LUNs.
+        - Option I(rpo) should be specified if the I(replication_mode) is C(asynchronous).
+        - The value should be in range of C(5) to C(1440).
+        type: int
+      replication_type:
+        description:
+        - Type of replication.
+        choices: ['local', 'remote']
+        default: local
+        type: str
+      remote_system:
+        description:
+        - Details of remote system to which the replication is being configured.
+        - The I(remote_system) option should be specified if the I(replication_type) is C(remote).
+        type: dict
+        suboptions:
+          remote_system_host:
+            required: true
+            description:
+            - IP or FQDN for remote Unity unisphere Host.
+            type: str
+          remote_system_username:
+            type: str
+            required: true
+            description:
+            - User name of remote Unity unisphere Host.
+          remote_system_password:
+            type: str
+            required: true
+            description:
+            - Password of remote Unity unisphere Host.
+          remote_system_verifycert:
+            type: bool
+            default: true
+            description:
+            - Boolean variable to specify whether or not to validate SSL
+              certificate of remote Unity unisphere Host.
+            - C(true) - Indicates that the SSL certificate should be verified.
+            - C(false) - Indicates that the SSL certificate should not be
+              verified.
+          remote_system_port:
+            description:
+            - Port at which remote Unity unisphere is hosted.
+            type: int
+            default: 443
+      destination_pool_name:
+        description:
+        - Name of pool to allocate destination Luns.
+        - Mutually exclusive with I(destination_pool_id).
+        type: str
+      destination_pool_id:
+        description:
+        - Id of pool to allocate destination Luns.
+        - Mutually exclusive with I(destination_pool_name).
+        type: str
+  replication_state:
+    description:
+    - State of the replication.
+    choices: ['enable', 'disable']
+    type: str
+  state:
+    description:
+    - Define whether the consistency group should exist or not.
+    choices: [absent, present]
+    required: true
+    type: str
+notes:
+  - The I(check_mode) is not supported.
+"""
+
+EXAMPLES = r"""
+- name: Create consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      validate_certs: "{{validate_certs}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      cg_name: "{{cg_name}}"
+      description: "{{description}}"
+      snap_schedule: "{{snap_schedule1}}"
+      state: "present"
+
+- name: Get details of consistency group using id
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_id: "{{cg_id}}"
+      state: "present"
+
+- name: Add volumes to consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_id: "{{cg_id}}"
+      volumes:
+          - vol_name: "Ansible_Test-3"
+          - vol_id: "sv_1744"
+      vol_state: "{{vol_state_present}}"
+      state: "present"
+
+- name: Rename consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_name: "{{cg_name}}"
+      new_cg_name: "{{new_cg_name}}"
+      state: "present"
+
+- name: Modify consistency group details
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_name: "{{new_cg_name}}"
+      snap_schedule: "{{snap_schedule2}}"
+      tiering_policy: "{{tiering_policy1}}"
+      state: "present"
+
+- name: Map hosts to a consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_id: "{{cg_id}}"
+      hosts:
+        - host_name: "10.226.198.248"
+        - host_id: "Host_511"
+      mapping_state: "mapped"
+      state: "present"
+
+- name: Unmap hosts from a consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_id: "{{cg_id}}"
+      hosts:
+        - host_id: "Host_511"
+        - host_name: "10.226.198.248"
+      mapping_state: "unmapped"
+      state: "present"
+
+- name: Remove volumes from consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_name: "{{new_cg_name}}"
+      volumes:
+        - vol_name: "Ansible_Test-3"
+        - vol_id: "sv_1744"
+      vol_state: "{{vol_state_absent}}"
+      state: "present"
+
+- name: Delete consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_name: "{{new_cg_name}}"
+      state: "absent"
+
+- name: Enable replication for consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_id: "cg_id_1"
+      replication_params:
+        destination_cg_name: "destination_cg_1"
+        replication_mode: "asynchronous"
+        rpo: 60
+        replication_type: "remote"
+        remote_system:
+          remote_system_host: '10.1.2.3'
+          remote_system_verifycert: False
+          remote_system_username: 'username'
+          remote_system_password: 'password'
+        destination_pool_name: "pool_test_1"
+      replication_state: "enable"
+      state: "present"
+
+- name: Disable replication for consistency group
+  dellemc.unity.consistencygroup:
+      unispherehost: "{{unispherehost}}"
+      username: "{{username}}"
+      password: "{{password}}"
+      validate_certs: "{{validate_certs}}"
+      cg_name: "dis_repl_ans_source"
+      replication_state: "disable"
+      state: "present"
+"""
+
+RETURN = r'''
+changed:
+    description: Whether or not the resource has changed.
+    returned: always
+    type: bool
+    sample: true
+
+consistency_group_details:
+    description: Details of the consistency group.
+    returned: When consistency group exists
+    type: dict
+    contains:
+        id:
+            description: The system ID given to the consistency group.
+            type: str
+        relocation_policy:
+            description: FAST VP tiering policy for the consistency group.
+            type: str
+        cg_replication_enabled:
+            description: Whether or not the replication is enabled..
+            type: bool
+        snap_schedule:
+            description: Snapshot schedule applied to consistency group.
+            type: dict
+            contains:
+                UnitySnapSchedule:
+                    description: Snapshot schedule applied to consistency
+                     group.
+                    type: dict
+                    contains:
+                        id:
+                            description: The system ID given to the
+                                         snapshot schedule.
+                            type: str
+                        name:
+                            description: The name of the snapshot schedule.
+                            type: str
+        luns:
+            description: Details of volumes part of consistency group.
+            type: dict
+            contains:
+                UnityLunList:
+                    description: List of volumes part of consistency group.
+                    type: list
+                    contains:
+                        UnityLun:
+                            description: Detail of volume.
+                            type: dict
+                            contains:
+                                id:
+                                    description: The system ID given to volume.
+                                    type: str
+                                name:
+                                    description: The name of the volume.
+                                    type: str
+        snapshots:
+            description: List of snapshots of consistency group.
+            type: list
+            contains:
+                name:
+                    description: Name of the snapshot.
+                    type: str
+                creation_time:
+                    description: Date and time on which the snapshot was taken.
+                    type: str
+                expirationTime:
+                    description: Date and time after which the snapshot will expire.
+                    type: str
+                storageResource:
+                    description: Storage resource for which the snapshot was
+                     taken.
+                    type: dict
+                    contains:
+                        UnityStorageResource:
+                            description: Details of the storage resource.
+                            type: dict
+                            contains:
+                                id:
+                                    description: The id of the storage
+                                                 resource.
+                                    type: str
+        block_host_access:
+            description: Details of hosts mapped to the consistency group.
+            type: dict
+            contains:
+                UnityBlockHostAccessList:
+                    description: List of hosts mapped to consistency group.
+                    type: list
+                    contains:
+                        UnityBlockHostAccess:
+                            description: Details of host.
+                            type: dict
+                            contains:
+                                id:
+                                    description: The ID of the host.
+                                    type: str
+                                name:
+                                    description: The name of the host.
+                                    type: str
+    sample: {
+        "advanced_dedup_status": "DedupStatusEnum.DISABLED",
+        "block_host_access": null,
+        "cg_replication_enabled": false,
+        "data_reduction_percent": 0,
+        "data_reduction_ratio": 1.0,
+        "data_reduction_size_saved": 0,
+        "data_reduction_status": "DataReductionStatusEnum.DISABLED",
+        "datastores": null,
+        "dedup_status": null,
+        "description": "Ansible testing",
+        "esx_filesystem_block_size": null,
+        "esx_filesystem_major_version": null,
+        "existed": true,
+        "filesystem": null,
+        "hash": 8776023812033,
+        "health": {
+            "UnityHealth": {
+                "hash": 8776023811889
+            }
+        },
+        "host_v_vol_datastore": null,
+        "id": "res_7477",
+        "is_replication_destination": false,
+        "is_snap_schedule_paused": null,
+        "luns": null,
+        "metadata_size": 0,
+        "metadata_size_allocated": 0,
+        "name": "Ansible_CG_Testing",
+        "per_tier_size_used": null,
+        "pools": null,
+        "relocation_policy": "TieringPolicyEnum.MIXED",
+        "replication_type": "ReplicationTypeEnum.NONE",
+        "size_allocated": 0,
+        "size_total": 0,
+        "size_used": null,
+        "snap_count": 0,
+        "snap_schedule": null,
+        "snaps_size_allocated": 0,
+        "snaps_size_total": 0,
+        "snapshots": [],
+        "thin_status": "ThinStatusEnum.FALSE",
+        "type": "StorageResourceTypeEnum.CONSISTENCY_GROUP",
+        "virtual_volumes": null,
+        "vmware_uuid": null
+    }
+'''
+
+import logging
+from ansible.module_utils.basic import AnsibleModule
+from ansible_collections.dellemc.unity.plugins.module_utils.storage.dell \
+    import utils
+
+LOG = utils.get_logger('consistencygroup',
+                       log_devel=logging.INFO)
+
+application_type = "Ansible/1.6.0"
+
+
+class ConsistencyGroup(object):
+    """Class with consistency group operations"""
+
+    def __init__(self):
+        """Define all parameters required by this module"""
+        self.module_params = utils.get_unity_management_host_parameters()
+        self.module_params.update(get_consistencygroup_parameters())
+
+        mutually_exclusive = [['cg_name', 'cg_id']]
+        required_one_of = [['cg_name', 'cg_id']]
+        required_together = [['volumes', 'vol_state'], ['hosts', 'mapping_state']]
+
+        # initialize the Ansible module
+        self.module = AnsibleModule(
+            argument_spec=self.module_params,
+            supports_check_mode=False,
+            mutually_exclusive=mutually_exclusive,
+            required_one_of=required_one_of,
+            required_together=required_together
+        )
+        utils.ensure_required_libs(self.module)
+
+        self.unity_conn = utils.get_unity_unisphere_connection(
+            self.module.params, application_type)
+
+    def return_cg_instance(self, cg_name):
+        """Return the consistency group instance.
+            :param cg_name: The name of the consistency group
+            :return: Instance of the consistency group
+        """
+
+        try:
+            cg_details = self.unity_conn.get_cg(name=cg_name)
+            cg_id = cg_details.get_id()
+            cg_obj = utils.cg.UnityConsistencyGroup.get(self.unity_conn._cli,
+                                                        cg_id)
+            return cg_obj
+
+        except Exception as e:
+            msg = "Failed to get the consistency group {0} instance with " \
+                  "error {1}".format(cg_name, str(e))
+            LOG.error(msg)
+            self.module.fail_json(msg=msg)
+
+    def get_details(self, cg_id=None, cg_name=None):
+        """Get consistency group details.
+            :param cg_id: The id of the consistency group
+            :param cg_name: The name of the consistency group
+            :return: Dict containing consistency group details if exists
+        """
+
+        id_or_name = cg_id if cg_id else cg_name
+        errormsg = "Failed to get details of consistency group {0} with" \
+                   " error {1}"
+
+        try:
+            cg_details = self.unity_conn.get_cg(_id=cg_id, name=cg_name)
+            if cg_name is None:
+                cg_name = cg_details.name
+
+            if cg_details.existed:
+                cg_obj = self.return_cg_instance(cg_name)
+                snapshots = cg_obj.snapshots
+
+                snapshot_list = [snap._get_properties() for snap in snapshots]
+
+                cg_ret_details = cg_details._get_properties()
+
+                # Append details of host mapped to the consistency group
+                # in return response
+                if cg_ret_details['block_host_access']:
+                    for i in range(len(cg_details.block_host_access)):
+                        cg_ret_details['block_host_access']['UnityBlockHostAccessList'][i]['UnityBlockHostAccess'][
+                            'id'] = cg_details.block_host_access[i].host.id
+                        cg_ret_details['block_host_access']['UnityBlockHostAccessList'][i]['UnityBlockHostAccess'][
+                            'name'] = cg_details.block_host_access[i].host.name
+                cg_ret_details['snapshots'] = snapshot_list
+
+                # Add volume name to the dict
+                if cg_ret_details['luns'] is not None:
+                    for i in range(len(cg_details.luns)):
+                        cg_ret_details['luns']['UnityLunList'][i]['UnityLun'][
+                            'name'] = cg_details.luns[i].name
+
+                # Add snapshot schedule name to the dict
+                if cg_ret_details['snap_schedule'] is not None:
+                    cg_ret_details['snap_schedule']['UnitySnapSchedule'][
+                        'name'] = cg_details.snap_schedule.name
+
+                # Status of cg replication
+                cg_ret_details['cg_replication_enabled'] = True if cg_details.check_cg_is_replicated() else False
+
+                return cg_ret_details
+            else:
+                LOG.info("Failed to get details of consistency group %s",
+                         id_or_name)
+                return None
+
+        except utils.HttpError as e:
+            if e.http_status == 401:
+                auth_err = "Incorrect username or password, {0}".format(
+                    e.message)
+                msg = errormsg.format(id_or_name, auth_err)
+                LOG.error(msg)
+                self.module.fail_json(msg=msg)
+            else:
+                msg = errormsg.format(id_or_name, str(e))
+                LOG.error(msg)
+                self.module.fail_json(msg=msg)
+
+        except utils.UnityResourceNotFoundError as e:
+            msg = errormsg.format(id_or_name, str(e))
+            LOG.error(msg)
+            return None
+
+        except Exception as e:
+            msg = errormsg.format(id_or_name, str(e))
+            LOG.error(msg)
+            self.module.fail_json(msg=msg)
+
+    def get_host_id_by_name(self, host_name):
+        """ Get host ID by host name
+        :param host_name: str
+        :return: unity host ID
+        :rtype: str
+        """
+        try:
+            host_obj = self.unity_conn.get_host(name=host_name)
+            if host_obj and host_obj.existed:
+                return host_obj.id
+            else:
+                msg = "Host name: %s does not exists" % host_name
+                LOG.error(msg)
+                self.module.fail_json(msg=msg)
+        except Exception as e:
+            msg = "Failed to get host ID by name: %s error: %s" % (
+                host_name, str(e))
+            LOG.error(msg)
+            self.module.fail_json(msg=msg)
+
+    def get_volume_details(self, vol_name=None, vol_id=None):
+        """Get the details of a volume.
+            :param vol_name: The name of the volume
+            :param vol_id: The id of the volume
+            :return: Dict containing volume details if exists
+        """
+
+        id_or_name = vol_id if vol_id else vol_name
+
+        try:
+            lun = self.unity_conn.get_lun(name=vol_name, _id=vol_id)
+
+            cg = None
+            if lun.existed:
+                lunid = lun.get_id()
+                unitylun = utils.UnityLun.get(self.unity_conn._cli, lunid)
+                if unitylun.cg is not None:
+                    cg = unitylun.cg
+            else:
+                errormsg = "The volume {0} not found.".format(id_or_name)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+            cg_details = self.get_details(
+                cg_id=self.module.params['cg_id'],
+                cg_name=self.module.params['cg_name'])
+
+            # Check if volume is already part of another consistency group
+            if cg is None:
+                return lun._get_properties()['id']
+
+            errormsg = "The volume {0} is already part of consistency group" \
+                       " {1}".format(id_or_name, cg.name)
+
+            if cg_details is None:
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+            if cg.id != cg_details['id']:
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+            return lun._get_properties()['id']
+
+        except Exception as e:
+            msg = "Failed to get the volume {0} with error {1}".format(
+                id_or_name, str(e))
+            LOG.error(msg)
+            self.module.fail_json(msg=msg)
+
+    def remove_volumes_from_cg(self, cg_name, volumes):
+        """Remove volumes from consistency group.
+            :param cg_name: The name of the consistency group
+            :param volumes: The list of volumes to be removed
+            :return: Boolean value to indicate if volumes are removed from
+             consistency group
+        """
+
+        cg_details = self.unity_conn.get_cg(name=cg_name)._get_properties()
+        existing_volumes_in_cg = cg_details['luns']
+        existing_vol_ids = []
+
+        if existing_volumes_in_cg:
+            existing_vol_ids = [vol['UnityLun']['id'] for vol in
+                                existing_volumes_in_cg['UnityLunList']]
+
+        ids_to_remove = []
+        vol_name_list = []
+        vol_id_list = []
+
+        for vol in volumes:
+            if 'vol_id' in vol and not (vol['vol_id'] in vol_id_list):
+                vol_id_list.append(vol['vol_id'])
+            elif 'vol_name' in vol and not (vol['vol_name'] in vol_name_list):
+                vol_name_list.append(vol['vol_name'])
+
+        """remove volume by name"""
+        for vol in vol_name_list:
+            ids_to_remove.append(self.get_volume_details(vol_name=vol))
+
+        vol_id_list = list(set(vol_id_list + ids_to_remove))
+        ids_to_remove = list(set(existing_vol_ids).intersection(set(vol_id_list)))
+
+        LOG.info("Volume IDs to remove %s", ids_to_remove)
+
+        if len(ids_to_remove) == 0:
+            return False
+
+        vol_remove_list = []
+        for vol in ids_to_remove:
+            vol_dict = {"id": vol}
+            vol_remove_list.append(vol_dict)
+
+        cg_obj = self.return_cg_instance(cg_name)
+
+        try:
+            cg_obj.modify(lun_remove=vol_remove_list)
+            return True
+        except Exception as e:
+            errormsg = "Remove existing volumes from consistency group {0} " \
+                       "failed with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def add_volumes_to_cg(self, cg_name, volumes, tiering_policy):
+        """Add volumes to consistency group.
+            :param cg_name: The name of the consistency group
+            :param volumes: The list of volumes to be added to consistency
+             group
+            :param tiering_policy: The tiering policy that is to be applied to
+            consistency group
+            :return: The boolean value to indicate if volumes are added to
+             consistency group
+        """
+
+        cg_details = self.unity_conn.get_cg(name=cg_name)._get_properties()
+        existing_volumes_in_cg = cg_details['luns']
+        existing_vol_ids = []
+
+        if existing_volumes_in_cg:
+            existing_vol_ids = [vol['UnityLun']['id'] for vol in
+                                existing_volumes_in_cg['UnityLunList']]
+
+        ids_to_add = []
+        vol_name_list = []
+        vol_id_list = []
+        all_vol_ids = []
+
+        for vol in volumes:
+            if 'vol_id' in vol and not (vol['vol_id'] in vol_id_list):
+                vol_id_list.append(vol['vol_id'])
+            elif 'vol_name' in vol and not (vol['vol_name'] in vol_name_list):
+                vol_name_list.append(vol['vol_name'])
+
+        """add volume by name"""
+        for vol in vol_name_list:
+            ids_to_add.append(self.get_volume_details(vol_name=vol))
+
+        """add volume by id"""
+        for vol in vol_id_list:
+            """verifying if volume id exists in array"""
+            ids_to_add.append(self.get_volume_details(vol_id=vol))
+
+        all_vol_ids = ids_to_add + existing_vol_ids
+        ids_to_add = list(set(all_vol_ids) - set(existing_vol_ids))
+
+        LOG.info("Volume IDs to add %s", ids_to_add)
+
+        if len(ids_to_add) == 0:
+            return False
+
+        vol_add_list = []
+        for vol in ids_to_add:
+            vol_dict = {"id": vol}
+            vol_add_list.append(vol_dict)
+
+        cg_obj = self.return_cg_instance(cg_name)
+
+        policy_enum = None
+        if tiering_policy:
+            if utils.TieringPolicyEnum[tiering_policy]:
+                policy_enum = utils.TieringPolicyEnum[tiering_policy]
+            else:
+                errormsg = "Invalid choice {0} for tiering policy".format(
+                    tiering_policy)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+        try:
+            cg_obj.modify(lun_add=vol_add_list, tiering_policy=policy_enum)
+            return True
+        except Exception as e:
+            errormsg = "Add existing volumes to consistency group {0} " \
+                       "failed with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def map_hosts_to_cg(self, cg_name, add_hosts):
+        """Map hosts to consistency group.
+            :param cg_name: The name of the consistency group
+            :param add_hosts: List of hosts that are to be mapped to cg
+            :return: Boolean value to indicate if hosts were mapped to cg
+        """
+        cg_details = self.unity_conn.get_cg(name=cg_name)
+        existing_volumes_in_cg = cg_details.luns
+
+        existing_hosts_in_cg = cg_details.block_host_access
+        existing_host_ids = []
+
+        """Get list of existing hosts in consistency group"""
+        if existing_hosts_in_cg:
+            for i in range(len(existing_hosts_in_cg)):
+                existing_host_ids.append(existing_hosts_in_cg[i].host.id)
+
+        host_id_list = []
+        host_name_list = []
+        add_hosts_id = []
+        host_add_list = []
+        all_hosts = []
+
+        for host in add_hosts:
+            if 'host_id' in host and not (host['host_id'] in host_id_list):
+                host_id_list.append(host['host_id'])
+            elif 'host_name' in host and not (host['host_name'] in host_name_list):
+                host_name_list.append(host['host_name'])
+
+        """add hosts by name"""
+        for host_name in host_name_list:
+            add_hosts_id.append(self.get_host_id_by_name(host_name))
+
+        all_hosts = host_id_list + existing_host_ids + add_hosts_id
+        add_hosts_id = list(set(all_hosts) - set(existing_host_ids))
+
+        if len(add_hosts_id) == 0:
+            return False
+
+        if existing_volumes_in_cg:
+
+            for host_id in add_hosts_id:
+                host_dict = {"id": host_id}
+                host_add_list.append(host_dict)
+
+            LOG.info("List of hosts to be added to consistency group "
+                     "%s ", host_add_list)
+            cg_obj = self.return_cg_instance(cg_name)
+            try:
+                cg_obj.modify(name=cg_name, host_add=host_add_list)
+                return True
+            except Exception as e:
+                errormsg = "Adding host to consistency group {0} " \
+                           "failed with error {1}".format(cg_name, str(e))
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+    def unmap_hosts_to_cg(self, cg_name, remove_hosts):
+        """Unmap hosts to consistency group.
+            :param cg_name: The name of the consistency group
+            :param remove_hosts: List of hosts that are to be unmapped from cg
+            :return: Boolean value to indicate if hosts were mapped to cg
+        """
+        cg_details = self.unity_conn.get_cg(name=cg_name)
+        existing_hosts_in_cg = cg_details.block_host_access
+        existing_host_ids = []
+
+        """Get host ids existing in consistency group"""
+        if existing_hosts_in_cg:
+            for i in range(len(existing_hosts_in_cg)):
+                existing_host_ids.append(existing_hosts_in_cg[i].host.id)
+
+        host_remove_list = []
+        host_id_list = []
+        host_name_list = []
+        remove_hosts_id = []
+
+        for host in remove_hosts:
+            if 'host_id' in host and not (host['host_id'] in host_id_list):
+                host_id_list.append(host['host_id'])
+            elif 'host_name' in host and not (host['host_name'] in host_name_list):
+                host_name_list.append(host['host_name'])
+
+        """remove hosts by name"""
+        for host in host_name_list:
+            remove_hosts_id.append(self.get_host_id_by_name(host))
+
+        host_id_list = list(set(host_id_list + remove_hosts_id))
+        remove_hosts_id = list(set(existing_host_ids).intersection(set(host_id_list)))
+
+        if len(remove_hosts_id) == 0:
+            return False
+
+        for host in remove_hosts_id:
+            host_dict = {"id": host}
+            host_remove_list.append(host_dict)
+        cg_obj = self.return_cg_instance(cg_name)
+        try:
+            cg_obj.modify(name=cg_name, host_remove=host_remove_list)
+            return True
+        except Exception as e:
+            errormsg = "Removing host from consistency group {0} " \
+                       "failed with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def rename_cg(self, cg_name, new_cg_name):
+        """Rename consistency group.
+            :param cg_name: The name of the consistency group
+            :param new_cg_name: The new name of the consistency group
+            :return: Boolean value to indicate if consistency group renamed
+        """
+        cg_obj = self.return_cg_instance(cg_name)
+
+        try:
+            cg_obj.modify(name=new_cg_name)
+            return True
+        except Exception as e:
+            errormsg = "Rename operation of consistency group {0} failed " \
+                       "with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def is_cg_modified(self, cg_details):
+        """Check if the desired consistency group state is different from
+            existing consistency group.
+            :param cg_details: The dict containing consistency group details
+            :return: Boolean value to indicate if modification is needed
+        """
+        modified = False
+
+        if self.module.params['tiering_policy'] and cg_details['luns'] is \
+                None and self.module.params['volumes'] is None:
+            self.module.fail_json(msg="The system cannot assign a tiering"
+                                      " policy to an empty consistency group."
+                                  )
+
+        if self.module.params['hosts'] and cg_details['luns'] is \
+                None and self.module.params['volumes'] is None:
+            self.module.fail_json(msg="The system cannot assign hosts"
+                                      " to an empty consistency group.")
+
+        if ((cg_details['description'] is not None and
+             self.module.params['description'] is not None and
+             cg_details['description'] != self.module.params['description'])
+                or (cg_details['description'] is None and
+                    self.module.params['description'] is not None)) or \
+            ((cg_details['snap_schedule'] is not None and
+              self.module.params['snap_schedule'] is not None and
+              cg_details['snap_schedule']['UnitySnapSchedule']['name'] !=
+              self.module.params['snap_schedule']) or
+             (cg_details['snap_schedule'] is None and
+              self.module.params['snap_schedule'])):
+            modified = True
+
+        if cg_details['relocation_policy']:
+            tier_policy = cg_details['relocation_policy'].split('.')
+            if self.module.params['tiering_policy'] is not None and \
+                    tier_policy[1] != self.module.params['tiering_policy']:
+                modified = True
+
+        return modified
+
+    def create_cg(self, cg_name, description, snap_schedule):
+        """Create a consistency group.
+            :param cg_name: The name of the consistency group
+            :param description: The description of the consistency group
+            :param snap_schedule: The name of the snapshot schedule
+            :return: The boolean value to indicate if consistency group
+             created and also returns the CG object
+        """
+
+        try:
+            if snap_schedule is not None:
+                snap_schedule = {"name": snap_schedule}
+
+            cg_obj = utils.cg.UnityConsistencyGroup.create(
+                self.unity_conn._cli, name=cg_name, description=description,
+                snap_schedule=snap_schedule)
+            return True, cg_obj
+        except Exception as e:
+            errormsg = "Create operation of consistency group {0} failed" \
+                       " with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def modify_cg(self, cg_name, description, snap_schedule, tiering_policy):
+        """Modify consistency group.
+            :param cg_name: The name of the consistency group
+            :param description: The description of the consistency group
+            :param snap_schedule: The name of the snapshot schedule
+            :param tiering_policy: The tiering policy that is to be applied to
+            consistency group
+            :return: The boolean value to indicate if consistency group
+             modified
+        """
+        cg_obj = self.return_cg_instance(cg_name)
+        is_snap_schedule_paused = None
+
+        if self.module.params['snap_schedule'] == "":
+            is_snap_schedule_paused = False
+
+        if snap_schedule is not None:
+            if snap_schedule == "":
+                snap_schedule = {"name": None}
+            else:
+                snap_schedule = {"name": snap_schedule}
+
+        policy_enum = None
+        if tiering_policy:
+            if utils.TieringPolicyEnum[tiering_policy]:
+                policy_enum = utils.TieringPolicyEnum[tiering_policy]
+            else:
+                errormsg = "Invalid choice {0} for tiering policy".format(
+                    tiering_policy)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+        try:
+            cg_obj.modify(description=description,
+                          snap_schedule=snap_schedule,
+                          tiering_policy=policy_enum,
+                          is_snap_schedule_paused=is_snap_schedule_paused)
+            return True
+
+        except Exception as e:
+            errormsg = "Modify operation of consistency group {0} failed " \
+                       "with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def delete_cg(self, cg_name):
+        """Delete consistency group.
+        :param cg_name: The name of the consistency group
+        :return: The boolean value to indicate if consistency group deleted
+        """
+        cg_obj = self.return_cg_instance(cg_name)
+
+        try:
+            cg_obj.delete()
+            return True
+
+        except Exception as e:
+            errormsg = "Delete operation of consistency group {0} failed " \
+                       "with error {1}".format(cg_name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def refine_volumes(self, volumes):
+        """Refine volumes.
+            :param volumes: Volumes that is to be added/removed
+            :return: List of volumes with each volume being identified with either
+            vol_id or vol_name
+        """
+        for vol in volumes:
+            if vol['vol_id'] is not None and vol['vol_name'] is None:
+                del vol['vol_name']
+            elif vol['vol_name'] is not None and vol['vol_id'] is None:
+                del vol['vol_id']
+        return volumes
+
+    def refine_hosts(self, hosts):
+        """Refine hosts.
+            :param hosts: Hosts that is to be mapped/unmapped
+            :return: List of hosts with each host being identified with either
+            host_id or host_name
+        """
+        for host in hosts:
+            if host['host_id'] is not None and host['host_name'] is None:
+                del host['host_name']
+            elif host['host_name'] is not None and host['host_id'] is None:
+                del host['host_id']
+        return hosts
+
+    def validate_volumes(self, volumes):
+        """Validate the volumes.
+            :param volumes: List of volumes
+        """
+
+        for vol in volumes:
+            if ('vol_id' in vol) and ('vol_name' in vol):
+                errormsg = "Both name and id are found for volume {0}. No" \
+                           " action would be taken. Please specify either" \
+                           " name or id.".format(vol)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            elif 'vol_id' in vol and (len(vol['vol_id'].strip()) == 0):
+                errormsg = "vol_id is blank. Please specify valid vol_id."
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            elif 'vol_name' in vol and (len(vol.get('vol_name').strip()) == 0):
+                errormsg = "vol_name is blank. Please specify valid vol_name."
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            elif 'vol_name' in vol:
+                self.get_volume_details(vol_name=vol['vol_name'])
+            elif 'vol_id' in vol:
+                self.get_volume_details(vol_id=vol['vol_id'])
+            else:
+                errormsg = "Expected either vol_name or vol_id, found" \
+                           " neither for volume {0}".format(vol)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+    def validate_hosts(self, hosts):
+        """Validate hosts.
+            :param hosts: List of hosts
+        """
+
+        for host in hosts:
+            if ('host_id' in host) and ('host_name' in host):
+                errormsg = "Both name and id are found for host {0}. No" \
+                           " action would be taken. Please specify either" \
+                           " name or id.".format(host)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            elif 'host_id' in host and (len(host['host_id'].strip()) == 0):
+                errormsg = "host_id is blank. Please specify valid host_id."
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            elif 'host_name' in host and (len(host.get('host_name').strip()) == 0):
+                errormsg = "host_name is blank. Please specify valid host_name."
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            elif 'host_name' in host:
+                self.get_host_id_by_name(host_name=host['host_name'])
+            elif 'host_id' in host:
+                host_obj = self.unity_conn.get_host(_id=host['host_id'])
+                if host_obj is None or host_obj.existed is False:
+                    msg = "Host id: %s does not exists" % host['host_id']
+                    LOG.error(msg)
+                    self.module.fail_json(msg=msg)
+
+            else:
+                errormsg = "Expected either host_name or host_id, found" \
+                           " neither for host {0}".format(host)
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+    def update_replication_params(self, replication):
+        ''' Update replication params '''
+
+        if 'replication_type' in replication and replication['replication_type'] == 'remote':
+            connection_params = {
+                'unispherehost': replication['remote_system']['remote_system_host'],
+                'username': replication['remote_system']['remote_system_username'],
+                'password': replication['remote_system']['remote_system_password'],
+                'validate_certs': replication['remote_system']['remote_system_verifycert'],
+                'port': replication['remote_system']['remote_system_port']
+            }
+            remote_system_conn = utils.get_unity_unisphere_connection(
+                connection_params, application_type)
+            replication['remote_system_name'] = remote_system_conn.name
+            if replication['destination_pool_name'] is not None:
+                pool_object = remote_system_conn.get_pool(name=replication['destination_pool_name'])
+                replication['destination_pool_id'] = pool_object.id
+        else:
+            if replication['destination_pool_name'] is not None:
+                pool_object = self.unity_conn.get_pool(name=replication['destination_pool_name'])
+                replication['destination_pool_id'] = pool_object.id
+
+    def get_destination_cg_luns(self, source_lun_list):
+        ''' Form destination cg lun list '''
+        destination_cg_lun_list = []
+        if source_lun_list is not None:
+            for source_lun in source_lun_list:
+                destination_cg_lun_info = utils.UnityStorageResource()
+                destination_cg_lun_info.name = "DR_" + source_lun.name
+                destination_cg_lun_info.is_thin_enabled = source_lun.is_thin_enabled
+                destination_cg_lun_info.size_total = source_lun.size_total
+                destination_cg_lun_info.id = source_lun.id
+                destination_cg_lun_info.is_data_reduction_enabled = source_lun.is_data_reduction_enabled
+                destination_cg_lun_list.append(destination_cg_lun_info)
+        return destination_cg_lun_list
+
+    def enable_cg_replication(self, cg_name, replication):
+        ''' Add replication to the consistency group '''
+        try:
+            # Validate replication params
+            self.validate_cg_replication_params(replication)
+
+            # Get cg instance
+            cg_object = self.return_cg_instance(cg_name)
+
+            # Check if replication is enabled for cg
+            if cg_object.check_cg_is_replicated():
+                return False
+
+            # Update replication params
+            self.update_replication_params(replication)
+
+            # Get destination pool id
+            replication_args_list = {
+                'dst_pool_id': replication['destination_pool_id']
+            }
+
+            # Get replication mode
+            if 'replication_mode' in replication and replication['replication_mode'] == 'asynchronous':
+                replication_args_list['max_time_out_of_sync'] = replication['rpo']
+            else:
+                replication_args_list['max_time_out_of_sync'] = -1
+
+            # Get remote system
+            if 'replication_type' in replication and replication['replication_type'] == 'remote':
+                remote_system_name = replication['remote_system_name']
+                remote_system_list = self.unity_conn.get_remote_system()
+                for remote_system in remote_system_list:
+                    if remote_system.name == remote_system_name:
+                        replication_args_list['remote_system'] = remote_system
+                        break
+                if 'remote_system' not in replication_args_list.keys():
+                    errormsg = "Remote system %s is not found" % (remote_system_name)
+                    LOG.error(errormsg)
+                    self.module.fail_json(msg=errormsg)
+
+            # Form destination LUNs list
+            source_lun_list = cg_object.luns
+            replication_args_list['source_luns'] = self.get_destination_cg_luns(source_lun_list)
+
+            # Form destination cg name
+            if 'destination_cg_name' in replication and replication['destination_cg_name'] is not None:
+                replication_args_list['dst_cg_name'] = replication['destination_cg_name']
+            else:
+                replication_args_list['dst_cg_name'] = "DR_" + cg_object.name
+
+            LOG.info(("Enabling replication to the consistency group %s", cg_object.name))
+            cg_object.replicate_cg_with_dst_resource_provisioning(**replication_args_list)
+            return True
+        except Exception as e:
+            errormsg = "Enabling replication to the consistency group %s failed " \
+                       "with error %s" % (cg_object.name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def disable_cg_replication(self, cg_name):
+        ''' Remove replication from the consistency group '''
+        try:
+            # Get cg instance
+            cg_object = self.return_cg_instance(cg_name)
+
+            # Check if replication is enabled for cg
+            if not cg_object.check_cg_is_replicated():
+                return False
+
+            LOG.info(("Disabling replication from the consistency group %s", cg_object.name))
+            curr_cg_repl_session = self.unity_conn.get_replication_session(src_resource_id=cg_object.id)
+            for repl_session in curr_cg_repl_session:
+                repl_session.delete()
+            return True
+        except Exception as e:
+            errormsg = "Disabling replication to the consistency group %s failed " \
+                       "with error %s" % (cg_object.name, str(e))
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def perform_module_operation(self):
+        """
+        Perform different actions on consistency group module based on
+        parameters chosen in playbook
+        """
+        cg_name = self.module.params['cg_name']
+        cg_id = self.module.params['cg_id']
+        description = self.module.params['description']
+        volumes = self.module.params['volumes']
+        snap_schedule = self.module.params['snap_schedule']
+        new_cg_name = self.module.params['new_cg_name']
+        tiering_policy = self.module.params['tiering_policy']
+        vol_state = self.module.params['vol_state']
+        hosts = self.module.params['hosts']
+        mapping_state = self.module.params['mapping_state']
+        replication = self.module.params['replication_params']
+        replication_state = self.module.params['replication_state']
+        state = self.module.params['state']
+
+        # result is a dictionary that contains changed status and consistency
+        # group details
+        result = dict(
+            changed=False,
+            create_cg='',
+            modify_cg='',
+            rename_cg='',
+            add_vols_to_cg='',
+            remove_vols_from_cg='',
+            delete_cg='',
+            add_hosts_to_cg='',
+            remove_hosts_from_cg='',
+            consistency_group_details={}
+        )
+        cg_details = self.get_details(cg_id=cg_id, cg_name=cg_name)
+
+        if cg_name is None and cg_details:
+            cg_id = None
+            cg_name = cg_details['name']
+        if volumes:
+            volumes = self.refine_volumes(volumes)
+            self.validate_volumes(volumes)
+        if hosts:
+            hosts = self.refine_hosts(hosts)
+            self.validate_hosts(hosts)
+
+        modified = False
+
+        if cg_details:
+            modified = self.is_cg_modified(cg_details)
+
+        if vol_state and not volumes:
+            self.module.fail_json(msg="Please specify volumes along with vol_state")
+
+        if mapping_state and not hosts:
+            self.module.fail_json(msg="Please specify hosts along with mapping_state")
+
+        if replication and replication_state is None:
+            self.module.fail_json(msg="Please specify replication_state along with replication_params")
+
+        if state == 'present' and not cg_details:
+            if not volumes and tiering_policy:
+                self.module.fail_json(msg="The system cannot assign a"
+                                          " tiering policy to an empty"
+                                          " consistency group")
+            if not volumes and hosts:
+                self.module.fail_json(msg="The system cannot assign"
+                                          " hosts to an empty"
+                                          " consistency group")
+
+            if not cg_name:
+                msg = "The parameter cg_name length is 0. It is too short." \
+                      " The min length is 1."
+                self.module.fail_json(msg=msg)
+
+            if new_cg_name:
+                self.module.fail_json(msg="Invalid argument, new_cg_name is"
+                                          " not required")
+
+            result['create_cg'], cg_details = self.create_cg(
+                cg_name, description, snap_schedule)
+        elif state == 'absent' and cg_details:
+            if cg_details['cg_replication_enabled']:
+                self.module.fail_json(msg="Consistency group cannot be deleted"
+                                          " because it is participating"
+                                          " in a replication session.")
+            if cg_details['luns']:
+                self.module.fail_json(msg="Please remove all volumes which"
+                                          " are part of consistency group"
+                                          " before deleting it.")
+            result['delete_cg'] = self.delete_cg(cg_name)
+
+        if state == 'present' and vol_state == 'present-in-group' and \
+                cg_details and volumes:
+            result['add_vols_to_cg'] = self.add_volumes_to_cg(cg_name,
+                                                              volumes,
+                                                              tiering_policy)
+        elif state == 'present' and vol_state == 'absent-in-group' and \
+                cg_details and volumes:
+            result['remove_vols_from_cg'] = self.remove_volumes_from_cg(
+                cg_name, volumes)
+
+        if hosts and mapping_state == 'mapped' and \
+                cg_details:
+            result['add_hosts_to_cg'] = self.map_hosts_to_cg(cg_name, hosts)
+
+        if hosts and mapping_state == 'unmapped' and \
+                cg_details:
+            result['remove_hosts_from_cg'] = self.unmap_hosts_to_cg(cg_name, hosts)
+
+        if state == 'present' and new_cg_name is not None:
+            if not new_cg_name:
+                msg = "The parameter new_cg_name length is 0. It is too" \
+                      " short. The min length is 1."
+                self.module.fail_json(msg=msg)
+
+            if cg_name != new_cg_name:
+                result['rename_cg'] = self.rename_cg(cg_name, new_cg_name)
+                cg_name = new_cg_name
+
+        if state == 'present' and cg_details and modified:
+            result['modify_cg'] = self.modify_cg(cg_name, description,
+                                                 snap_schedule, tiering_policy
+                                                 )
+
+        if state == 'present' and cg_details and replication_state is not None:
+            if replication_state == 'enable':
+                result['changed'] = self.enable_cg_replication(cg_name, replication)
+            else:
+                result['changed'] = self.disable_cg_replication(cg_name)
+
+        if result['create_cg'] or result['modify_cg'] or result[
+            'add_vols_to_cg'] or result['remove_vols_from_cg'] or result[
+            'delete_cg'] or result['rename_cg'] or result[
+                'add_hosts_to_cg'] or result['remove_hosts_from_cg']:
+            result['changed'] = True
+
+        result['consistency_group_details'] = self.get_details(cg_id=cg_id,
+                                                               cg_name=cg_name
+                                                               )
+
+        self.module.exit_json(**result)
+
+    def validate_destination_pool_info(self, replication):
+        if replication['destination_pool_id'] is not None and replication['destination_pool_name'] is not None:
+            errormsg = "'destination_pool_id' and 'destination_pool_name' is mutually exclusive."
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+        if replication['destination_pool_id'] is None and replication['destination_pool_name'] is None:
+            errormsg = "Either 'destination_pool_id' or 'destination_pool_name' is required."
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+
+    def validate_replication_mode(self, replication):
+        if 'replication_mode' in replication and replication['replication_mode'] == 'asynchronous':
+            if replication['rpo'] is None:
+                errormsg = "rpo is required together with 'asynchronous' replication_mode."
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            if replication['rpo'] < 5 or replication['rpo'] > 1440:
+                errormsg = "rpo value should be in range of 5 to 1440"
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+
+    def validate_cg_replication_params(self, replication):
+        ''' Validate cg replication params '''
+        # Valdiate replication
+        if replication is None:
+            errormsg = "Please specify replication_params to enable replication."
+            LOG.error(errormsg)
+            self.module.fail_json(msg=errormsg)
+        else:
+            self.validate_destination_pool_info(replication)
+            self.validate_replication_mode(replication)
+            # Validate replication type
+            if replication['replication_type'] == 'remote' and replication['remote_system'] is None:
+                errormsg = "remote_system is required together with 'remote' replication_type"
+                LOG.error(errormsg)
+                self.module.fail_json(msg=errormsg)
+            # Validate destination cg name
+            if 'destination_cg_name' in replication and replication['destination_cg_name'] is not None:
+                dst_cg_name_length = len(replication['destination_cg_name'])
+                if dst_cg_name_length == 0 or dst_cg_name_length > 95:
+                    errormsg = "destination_cg_name value should be in range of 1 to 95"
+                    LOG.error(errormsg)
+                    self.module.fail_json(msg=errormsg)
+
+
+def get_consistencygroup_parameters():
+    """This method provide parameters required for the ansible consistency
+        group module on Unity"""
+    return dict(
+        cg_name=dict(required=False, type='str'),
+        cg_id=dict(required=False, type='str'),
+        description=dict(required=False, type='str'),
+        volumes=dict(required=False, type='list', elements='dict',
+                     options=dict(
+                         vol_name=dict(type='str'),
+                         vol_id=dict(type='str')
+                     )
+                     ),
+        snap_schedule=dict(required=False, type='str'),
+        new_cg_name=dict(required=False, type='str'),
+        tiering_policy=dict(required=False, type='str', choices=[
+            'AUTOTIER_HIGH', 'AUTOTIER', 'HIGHEST', 'LOWEST']),
+        vol_state=dict(required=False, type='str',
+                       choices=['present-in-group', 'absent-in-group']),
+        hosts=dict(required=False, type='list', elements='dict',
+                   options=dict(
+                       host_name=dict(type='str'),
+                       host_id=dict(type='str')
+                   )),
+        mapping_state=dict(required=False, type='str',
+                           choices=['mapped', 'unmapped']),
+        replication_params=dict(type='dict', options=dict(
+            destination_cg_name=dict(type='str'),
+            replication_mode=dict(type='str', choices=['asynchronous', 'manual'], required=True),
+            rpo=dict(type='int'),
+            replication_type=dict(type='str', choices=['local', 'remote'], default='local'),
+            remote_system=dict(type='dict',
+                               options=dict(
+                                    remote_system_host=dict(type='str', required=True, no_log=True),
+                                    remote_system_verifycert=dict(type='bool', required=False,
+                                                                  default=True),
+                                    remote_system_username=dict(type='str', required=True),
+                                    remote_system_password=dict(type='str', required=True, no_log=True),
+                                    remote_system_port=dict(type='int', required=False, default=443, no_log=True)
+                               )),
+            destination_pool_name=dict(type='str'),
+            destination_pool_id=dict(type='str')
+        )),
+        replication_state=dict(type='str', choices=['enable', 'disable']),
+        state=dict(required=True, type='str', choices=['present', 'absent'])
+    )
+
+
+def main():
+    """ Create Unity consistency group object and perform action on it
+        based on user input from playbook"""
+    obj = ConsistencyGroup()
+    obj.perform_module_operation()
+
+
+if __name__ == '__main__':
+    main()