# Copyright (c) 2016 FalconStor, Inc.
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

import base64
import json
import random
import time
import uuid

from oslo_log import log as logging
from oslo_utils import excutils
from oslo_utils import units
from six.moves import http_client

from cinder import exception
from cinder.i18n import _, _LI, _LW


FSS_BATCH = 'batch'
FSS_PHYSICALRESOURCE = 'physicalresource'
FSS_PHYSICALADAPTER = 'physicaladapter'
FSS_FCCLIENTINITIATORS = 'fcclientinitiators'
FSS_FC_TGT_WWPN = 'fctgtwwpn'
FSS_STORAGE_POOL = 'storagepool'
FSS_LOGICALRESOURCE = 'logicalresource'
FSS_SAN = 'sanresource'
FSS_MIRROR = 'mirror'
FSS_TIMEMARKPOLICY = 'timemarkpolicy'
FSS_TIMEMARK = 'timemark'
FSS_TIMEVIEW = 'timeview'
FSS_SNAPSHOT_RESOURCE = 'snapshotresource'
FSS_SNAPSHOT_GROUP = 'snapshotgroup'
FSS_CLIENT = 'client'
FSS_SANCLIENT = 'sanclient'
FSS_ISCSI_TARGET = 'iscsitarget'
FSS_ISCSI_CLIENT_INITIATORS = 'iscsiclientinitiators'
FSS_SERVER = 'server'
FSS_OPTIONS = 'options'
FSS_PORTAL = 'defaultiscsiportal'
FSS_PROPERTIES = 'properties'
FSS_HOST = 'host'
FSS_RETURN_CODE = 'rcs'
FSS_AUTH = 'auth'
FSS_LOGIN = 'login'
FSS_SINGLE_TYPE = 'single'


POST = 'POST'
GET = 'GET'
PUT = 'PUT'
DELETE = 'DELETE'
GROUP_PREFIX = 'OpenStack-'
PRODUCT_NAME = 'ipstor'
SESSION_COOKIE_NAME = 'session_id'
RETRY_LIST = ['107', '2147680512']

MAXSNAPSHOTS = 1000
OPERATION_TIMEOUT = 60 * 60
RETRY_CNT = 5
RETRY_INTERVAL = 15

LOG = logging.getLogger(__name__)


class RESTProxy(object):
    def __init__(self, config):
        self.fss_host = config.san_ip
        self.fss_username = config.san_login
        self.fss_password = config.san_password
        self.fss_defined_pool = config.fss_pool
        if config.additional_retry_list:
            RETRY_LIST.append(config.additional_retry_list)

        self.FSS = FSSRestCommon(
            host=self.fss_host,
            username=self.fss_username,
            password=self.fss_password,
            fss_debug=config.fss_debug)
        self.session_id = None

    # naming
    def _get_vol_name_from_snap(self, snapshot):
        """Return the name of the snapshot that FSS will use."""
        return "cinder-%s" % snapshot["volume_id"]

    def _get_fss_volume_name(self, volume):
        """Return the name of the volume FSS will use."""
        return "cinder-%s" % volume["id"]

    def _get_group_name_from_id(self, id):
        return "cinder-consisgroup-%s" % id

    def _encode_name(self, name):
        uuid_str = name.replace("-", "")
        vol_uuid = uuid.UUID('urn:uuid:%s' % uuid_str)
        newuuid = (base64.urlsafe_b64encode(vol_uuid.bytes).
                   decode('utf-8').strip('='))
        return "cinder-%s" % newuuid

    def do_setup(self):
        self.session_id = self.FSS.fss_login()

    def _convert_size_to_gb(self, size):
        s = round(float(size) / units.Gi, 2)
        if s > 0:
            return s
        else:
            return 0

    def _convert_size_to_mb(self, size):
        return size * units.Ki

    def _get_pools_info(self):
        qpools = []
        poolinfo = {}
        try:
            output = self.list_pool_info()
            if "storagepools" in output['data']:
                for item in output['data']['storagepools']:
                    if item['name'].startswith(GROUP_PREFIX) and (
                            self.fss_defined_pool == item['id']):
                        poolid = int(item['id'])
                        qpools.append(poolid)
                        break

            if not qpools:
                msg = _('The storage pool information is empty or not correct')
                raise exception.DriverNotInitialized(msg)

            # Query pool detail information
            for poolid in qpools:
                output = self.list_pool_info(poolid)
                poolinfo['pool_name'] = output['data']['name']
                poolinfo['total_capacity_gb'] = (
                    self._convert_size_to_gb(output['data']['size']))
                poolinfo['used_gb'] = (
                    self._convert_size_to_gb(output['data']['used']))
                poolinfo['QoS_support'] = False
                poolinfo['reserved_percentage'] = 0
        except Exception:
            msg = (_('Unexpected exception during get pools info.'))
            LOG.exception(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        return poolinfo

    def list_pool_info(self, pool_id=None):
        return self.FSS.list_pool_info(pool_id)

    def list_physicaladapter_info(self, adapter_id=None):
        return self.FSS.list_physicaladapter_info(adapter_id)

    def _checking_adapter_type(self, id):
        adapter_type = ''
        output = self.list_physicaladapter_info()
        if "physicaladapters" in output['data']:
            physicaladapters = output['data']['physicaladapters']
            if physicaladapters['id'] == id:
                adapter_type = physicaladapters['type']
        return adapter_type

    def create_vdev(self, volume):
        sizemb = self._convert_size_to_mb(volume["size"])
        volume_name = self._get_fss_volume_name(volume)
        params = dict(storagepoolid=self.fss_defined_pool,
                      category="virtual",
                      sizemb=sizemb,
                      name=volume_name)
        return volume_name, self.FSS.create_vdev(params)

    def create_tv_from_cdp_tag(self, volume_metadata, volume):
        tv_vid = ''
        cdp_tag = ''

        if 'cdptag' in volume_metadata:
            tv_vid = str(volume_metadata['timeview']) + '_0'
            cdp_tag = str(volume_metadata['cdptag'])

        if 'rawtimestamp' in volume_metadata:
            tv_vid = '{0}_{1}'.format(str(volume_metadata['timeview']),
                                      str(volume_metadata['rawtimestamp']))
        volume_name = self._get_fss_volume_name(volume)
        sizemb = self._convert_size_to_mb(volume['size'])
        params = dict(name=volume_name,
                      storage=dict(storagepoolid=self.fss_defined_pool,
                                   sizemb=sizemb),
                      automaticexpansion=dict(enabled=False),
                      timeviewcopy=True)
        if cdp_tag:
            params.update(cdpjournaltag=cdp_tag)

        metadata = self.FSS.create_timeview(tv_vid, params)
        return volume_name, metadata

    def create_thin_vdev(self, volume_metadata, volume):
        thin_size = 0
        size = volume["size"]
        sizemb = self._convert_size_to_mb(size)
        params = dict(storagepoolid=self.fss_defined_pool,
                      category="virtual")

        if 'thinprovisioned' in volume_metadata:
            if volume_metadata['thinprovisioned'] is False:
                msg = (_('If you want to create a thin provisioning volume,'
                         ' this param must be True.'))
                raise exception.VolumeBackendAPIException(msg)

        if 'thinsize' in volume_metadata:
            thin_size = int(volume_metadata['thinsize'])

        if size < 10:
            msg = _('The resource is a FSS thin device, minimum size is '
                    '10240 MB.')
            raise exception.VolumeBackendAPIException(msg)
        else:
            try:
                if thin_size > size:
                    msg = _('The allocated size must less than total size.')
                    raise exception.VolumeBackendAPIException(msg)
            except Exception:
                msg = _('The resource is a thin device, thin size is invalid.')
                raise exception.VolumeBackendAPIException(msg)

            thin_size = self._convert_size_to_mb(thin_size)
            thin_disk = dict(
                enabled=True,
                fullsizemb=sizemb)
            params.update(thinprovisioning=thin_disk)
            params.update(sizemb=thin_size)

        volume_name = self._get_fss_volume_name(volume)
        params.update(name=volume_name)
        return volume_name, self.FSS.create_vdev(params)

    def _get_fss_vid_from_name(self, volume_name, fss_type=None):
        vid = []
        output = self.FSS.list_fss_volume_info()
        try:
            if "virtualdevices" in output['data']:
                for item in output['data']['virtualdevices']:
                    if item['name'] in volume_name:
                        vid.append(item['id'])
        except Exception:
            msg = (_('Can not find cinder volume - %(volumeName)s') %
                   {"volumeName": volume_name})
            raise exception.VolumeBackendAPIException(msg)

        if fss_type is not None and fss_type == FSS_SINGLE_TYPE:
            vid = ''.join(str(x) for x in vid)
        return vid

    def _get_fss_gid_from_name(self, group_name):
        gid = ''
        output = self.FSS.list_group_info()
        if "snapshotgroups" in output['data']:
            for item in output['data']['snapshotgroups']:
                if item['name'] == group_name:
                    gid = item['id']
                    break
            if gid == '':
                msg = (_('Can not find consistency group: %s.') % group_name)
                raise exception.VolumeBackendAPIException(msg)
        return gid

    def _get_fss_group_membercount(self, gid):
        membercount = 0
        output = self.FSS.list_group_info(gid)
        if "membercount" in output['data']:
            membercount = output['data']['membercount']
        return membercount

    def _get_vdev_id_from_group_id(self, group_id):
        vidlist = []
        output = self.FSS.list_group_info(group_id)
        if "virtualdevices" in output['data']:
            for item in output['data']['virtualdevices']:
                vidlist.append(item['id'])
        return vidlist

    def clone_volume(self, new_vol_name, source_volume_name):
        params = dict(storagepoolid=self.fss_defined_pool)
        volume_metadata = {}
        new_vid = ''
        vid = self._get_fss_vid_from_name(source_volume_name, FSS_SINGLE_TYPE)
        mirror_params = dict(
            category='virtual',
            selectioncriteria='anydrive',
            mirrortarget="virtual"
        )
        mirror_params.update(params)
        ret1 = self.FSS.create_mirror(vid, mirror_params)

        if ret1:
            if ret1['rc'] != 0:
                failed_ret = self.FSS.get_fss_error_code(ret1['rc'])
                raise exception.VolumeBackendAPIException(data=failed_ret)

        ret2 = self.FSS.sync_mirror(vid)
        self.FSS._random_sleep()
        if ret2['rc'] == 0:
            self.FSS._check_mirror_sync_finished(vid, OPERATION_TIMEOUT)
            ret3 = self.FSS.promote_mirror(vid, new_vol_name)
            if ret3 and ret3['rc'] == 0:
                new_vid = ret3['id']

        volume_metadata['FSS-vid'] = new_vid
        return volume_metadata

    def delete_vdev(self, volume):
        volume_name = self._get_fss_volume_name(volume)
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        if vid:
            return self.FSS.delete_vdev(vid)
        else:
            msg = _('vid is null. FSS failed to delete volume.')
            raise exception.VolumeBackendAPIException(data=msg)

    def create_snapshot(self, snapshot):
        snap_metadata = {}
        volume_name = self._get_vol_name_from_snap(snapshot)
        snap_name = snapshot["display_name"]
        size = snapshot['volume_size']
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        if not vid:
            msg = _('vid is null. FSS failed to create snapshot.')
            raise exception.VolumeBackendAPIException(data=msg)

        (snap, tm_policy, vdev_size) = (self.FSS.
                                        _check_if_snapshot_tm_exist(vid))

        if not snap:
            self.create_vdev_snapshot(vid, self._convert_size_to_mb(size))
        if not tm_policy:
            self.FSS.create_timemark_policy(
                vid, storagepoolid=self.fss_defined_pool)
        if not snap_name:
            snap_name = "snap-%s" % time.strftime('%Y%m%d%H%M%S')

        self.FSS.create_timemark(vid, snap_name)
        snap_metadata['fss_tm_comment'] = snap_name
        return snap_metadata

    def delete_snapshot(self, snapshot):
        volume_name = self._get_vol_name_from_snap(snapshot)
        snap_name = snapshot["display_name"]
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        if not vid:
            msg = _('vid is null. FSS failed to delete snapshot')
            raise exception.VolumeBackendAPIException(data=msg)
        if not snap_name:
            if ('metadata' in snapshot and 'fss_tm_comment' in
               snapshot['metadata']):
                snap_name = snapshot['metadata']['fss_tm_comment']

        tm_info = self.FSS.get_timemark(vid)
        rawtimestamp = self._get_timestamp(tm_info, snap_name)
        if rawtimestamp:
            timestamp = '%s_%s' % (vid, rawtimestamp)
            self.FSS.delete_timemark(timestamp)

            final_tm_data = self.FSS.get_timemark(vid)
            if "timemark" in final_tm_data['data']:
                if not final_tm_data['data']['timemark']:
                    self.FSS.delete_timemark_policy(vid)
                    self.FSS.delete_vdev_snapshot(vid)

    def _get_timestamp(self, tm_data, encode_snap_name):
        timestamp = ''
        if "timemark" in tm_data['data']:
            for item in tm_data['data']['timemark']:
                if "comment" in item and item['comment'] == encode_snap_name:
                    timestamp = item['rawtimestamp']
                    break
        return timestamp

    def create_volume_from_snapshot(self, volume, snapshot):
        volume_metadata = {}
        volume_name = self._get_vol_name_from_snap(snapshot)
        snap_name = snapshot["display_name"]
        new_vol_name = self._get_fss_volume_name(volume)
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        if not vid:
            msg = _('vid is null. FSS failed to create_volume_from_snapshot.')
            raise exception.VolumeBackendAPIException(data=msg)

        if not snap_name:
            if ('metadata' in snapshot) and ('fss_tm_comment'
                                             in snapshot['metadata']):
                snap_name = snapshot['metadata']['fss_tm_comment']

        tm_info = self.FSS.get_timemark(vid)
        rawtimestamp = self._get_timestamp(tm_info, snap_name)
        if not rawtimestamp:
            msg = _('rawtimestamp is null. FSS failed to '
                    'create_volume_from_snapshot.')
            raise exception.VolumeBackendAPIException(data=msg)

        timestamp = '%s_%s' % (vid, rawtimestamp)
        output = self.FSS.copy_timemark(
            timestamp, storagepoolid=self.fss_defined_pool, name=new_vol_name)
        if output['rc'] == 0:
            vid = output['id']
            self.FSS._random_sleep()
            if self.FSS._check_tm_copy_finished(vid, OPERATION_TIMEOUT):
                volume_metadata['FSS-vid'] = vid
                return volume_name, volume_metadata

    def extend_vdev(self, volume_name, vol_size, new_size):
        if new_size > vol_size:
            vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
            size = self._convert_size_to_mb(new_size - vol_size)
            params = dict(
                action='expand',
                sizemb=size
            )
            return self.FSS.extend_vdev(vid, params)

    def list_volume_info(self, vid):
        return self.FSS.list_fss_volume_info(vid)

    def rename_vdev(self, vid, new_vol_name):
        params = dict(
            action='update',
            name=new_vol_name
        )
        return self.FSS.rename_vdev(vid, params)

    def assign_iscsi_vdev(self, client_id, target_id, vid):
        params = dict(
            action="assign",
            virtualdeviceids=[vid],
            iscsi=dict(target=target_id)
        )
        return self.FSS.assign_vdev(client_id, params)

    def assign_fc_vdev(self, client_id, vid):
        params = dict(
            action="assign",
            virtualdeviceids=[vid],
            fc=dict(
                fcmapping='alltoall',
                accessmode='readwritenonexclusive')
        )
        return self.FSS.assign_vdev(client_id, params)

    def unassign_vdev(self, client_id, vid):
        params = dict(
            action="unassign",
            virtualdeviceid=vid
        )
        return self.FSS.unassign_vdev(client_id, params)

    def _create_vdev_snapshot(self, volume_name, size):
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        return self.create_vdev_snapshot(vid, self._convert_size_to_mb(size))

    def create_vdev_snapshot(self, vid, size):
        params = dict(
            idlist=[vid],
            selectioncriteria='anydrive',
            policy='alwayswrite',
            sizemb=size,
            storagepoolid=self.fss_defined_pool
        )
        return self.FSS.create_vdev_snapshot(params)

    def create_group(self, group):
        group_name = self._get_group_name_from_id(group['id'])
        params = dict(
            name=group_name
        )
        return self.FSS.create_group(params)

    def destroy_group(self, group):
        group_name = self._get_group_name_from_id(group['id'])
        gid = self._get_fss_gid_from_name(group_name)
        return self.FSS.destroy_group(gid)

    def _add_volume_to_consistency_group(self, group_id, vol_name):
        self.set_group(group_id, addvollist=[vol_name])

    def set_group(self, group_id, **kwargs):
        group_name = self._get_group_name_from_id(group_id)
        gid = self._get_fss_gid_from_name(group_name)

        join_params = dict()
        leave_params = dict()
        if kwargs.get('addvollist'):
            joing_vid = self._get_fss_vid_from_name(kwargs['addvollist'])
            join_params.update(
                action='join',
                virtualdevices=joing_vid
            )
        if kwargs.get('remvollist'):
            leave_vid = self._get_fss_vid_from_name(kwargs['remvollist'])
            leave_params.update(
                action='leave',
                virtualdevices=leave_vid
            )
        return self.FSS.set_group(gid, join_params, leave_params)

    def create_cgsnapshot(self, cgsnapshot):
        group_name = self._get_group_name_from_id(
            cgsnapshot['consistencygroup_id'])
        gsnap_name = self._encode_name(cgsnapshot['id'])
        gid = self._get_fss_gid_from_name(group_name)
        vidlist = self._get_vdev_id_from_group_id(gid)

        for vid in vidlist:
            (snap, tm_policy, sizemb) = (self.FSS.
                                         _check_if_snapshot_tm_exist(vid))
            if not snap:
                self.create_vdev_snapshot(vid, sizemb)
            if not tm_policy:
                self.FSS.create_timemark_policy(
                    vid, storagepoolid=self.fss_defined_pool)

        group_tm_policy = self.FSS._check_if_group_tm_enabled(gid)
        if not group_tm_policy:
            self.create_group_timemark_policy(gid)

        self.create_group_timemark(gid, gsnap_name)

    def create_group_timemark_policy(self, gid):
        tm_params = dict(
            automatic=dict(enabled=False),
            maxtimemarkcount=MAXSNAPSHOTS
        )
        return self.FSS.create_group_timemark_policy(gid, tm_params)

    def create_group_timemark(self, gid, gsnap_name):
        params = dict(
            comment=gsnap_name,
            priority='medium',
            snapshotnotification=False
        )
        return self.FSS.create_group_timemark(gid, params)

    def delete_cgsnapshot(self, cgsnapshot):
        group_name = self._get_group_name_from_id(
            cgsnapshot['consistencygroup_id'])
        encode_snap_name = self._encode_name(cgsnapshot['id'])
        gid = self._get_fss_gid_from_name(group_name)

        if not gid:
            msg = _('gid is null. FSS failed to delete cgsnapshot.')
            raise exception.VolumeBackendAPIException(data=msg)

        if self._get_fss_group_membercount(gid) != 0:
            tm_info = self.FSS.get_group_timemark(gid)
            rawtimestamp = self._get_timestamp(tm_info, encode_snap_name)
            timestamp = '%s_%s' % (gid, rawtimestamp)
            self.delete_group_timemark(timestamp)

        final_tm_data = self.FSS.get_group_timemark(gid)
        if "timemark" in final_tm_data['data']:
            if not final_tm_data['data']['timemark']:
                self.FSS.delete_group_timemark_policy(gid)

    def delete_group_timemark(self, timestamp):
        params = dict(
            deleteallbefore=False
        )
        return self.FSS.delete_group_timemark(timestamp, params)

    def _check_iscsi_option(self):
        output = self.FSS.get_server_options()
        if "iscsitarget" in output['data']:
            if not output['data']['iscsitarget']:
                self.FSS.set_server_options('iscsitarget')

    def _check_fc_target_option(self):
        output = self.FSS.get_server_options()
        if "fctarget" in output['data']:
            if not output['data']['fctarget']:
                self.FSS.set_server_options('fctarget')

    def _check_iocluster_state(self):
        output = self.FSS.get_server_options()
        if 'iocluster' not in output['data']:
            msg = _('No iocluster information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        return output['data']['iocluster']

    def list_fc_target_wwpn(self):
        return self.FSS.list_fc_target_wwpn()

    def list_fc_client_initiators(self):
        return self.FSS.list_fc_client_initiators()

    def create_fc_client(self, cinder_host_name, free_initiator_wwpns):
        client_id = 0
        params = dict(
            name=cinder_host_name,
            protocoltype=["fc"],
            ipaddress=self.fss_host,
            ostype='linux',
            fcpolicy=dict(
                initiators=[free_initiator_wwpns],
                vsaenabled=False
            )
        )
        client_info = self.FSS.create_client(params)
        if client_info and client_info['rc'] == 0:
            client_id = client_info['id']
        return client_id

    def list_iscsi_target_info(self, target_id=None):
        return self.FSS.list_iscsi_target_info(target_id)

    def _check_fc_host_devices_empty(self, client_id):
        is_empty = False
        output = self.FSS.list_sanclient_info(client_id)
        if 'data' not in output:
            msg = _('No target in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        if 'fcdevices' not in output['data']:
            msg = _('No fcdevices in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        if len(output['data']['fcdevices']) == 0:
            is_empty = True
            self.FSS.delete_client(client_id)
        return is_empty

    def create_iscsi_client(self, cinder_host_name, initiator):
        params = dict(
            name=cinder_host_name,
            protocoltype=["iscsi"],
            ipaddress=self.fss_host,
            ostype='linux',
            iscsipolicy=dict(
                initiators=[initiator],
                authentication=dict(enabled=False,
                                    mutualchap=dict(enabled=False))
            )
        )
        return self.FSS.create_client(params)

    def create_iscsitarget(self, client_id, initiator, fss_hosts):
        params = dict(
            clientid=client_id,
            name=initiator,
            ipaddress=fss_hosts,
            accessmode='readwritenonexclusive'
        )
        return self.FSS.create_iscsitarget(params)

    def _get_iscsi_host(self, connector):
        target_info = self.list_iscsi_target_info()
        if 'data' not in target_info:
            msg = _('No data information in return info.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'iscsitargets' not in target_info['data']:
            msg = _('No iscsitargets in return info.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        if target_info['data']['iscsitargets']:
            iscsitargets = target_info['data']['iscsitargets']
            for iscsitarget in iscsitargets:
                if connector["initiator"] in iscsitarget["name"]:
                    target_id = iscsitarget["id"]
                    client_id = iscsitarget["clientid"]
                    return client_id, target_id
        return None, None

    def _create_iscsi_host(self, host_name, initiator, fss_hosts):
        client_id = ''
        target_id = ''
        client_info = self.create_iscsi_client(host_name, initiator)
        if client_info and client_info['rc'] == 0:
            client_id = client_info['id']

        target_info = self.create_iscsitarget(client_id, initiator, fss_hosts)
        if target_info['rc'] == 0:
            target_id = target_info['id']
        return client_id, target_id

    def _get_fc_client_initiators(self, connector):
        fc_initiators_assigned = []
        fc_available_initiator = []
        fc_initiators_info = self.list_fc_client_initiators()
        if 'data' not in fc_initiators_info:
            raise ValueError(_('No data information in return info.'))

        if fc_initiators_info['data']:
            fc_initiators = fc_initiators_info['data']
            for fc_initiator in fc_initiators:
                if fc_initiator['wwpn'] in connector['wwpns']:
                    fc_available_initiator.append(str(fc_initiator['wwpn']))
                    fc_initiators_assigned.append(dict(
                        wwpn=str(fc_initiator['wwpn']),
                        assigned=fc_initiator['assigned']))
        return fc_available_initiator, fc_initiators_assigned

    def fc_initialize_connection(self, volume, connector, fss_hosts):
        """Connect the host and volume; return dict describing connection."""
        vid = 0
        fc_target_info = {}
        free_fc_initiator = None

        volume_name = self._get_fss_volume_name(volume)
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        if not vid:
            msg = (_('Can not find cinder volume - %s.') % volume_name)
            raise exception.VolumeBackendAPIException(msg)

        available_initiator, fc_initiators_info = (
            self._get_fc_client_initiators(connector))

        if fc_initiators_info is None:
            msg = _('No FC initiator can be added to host.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        for fc_initiator in fc_initiators_info:
            value = fc_initiator['assigned']
            if len(value) == 0:
                free_fc_initiator = fc_initiator['wwpn']

        if free_fc_initiator is None:
            msg = _('No free FC initiator can be assigned to host.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        initiator = connector["initiator"]
        host_name = GROUP_PREFIX + '%s-' % connector["host"]

        initiator_name = initiator.split(':')
        idx = len(initiator_name) - 1
        client_host_name = host_name + initiator_name[
            idx] + '_FC-wwpn-' + free_fc_initiator

        client_id = self.create_fc_client(client_host_name, free_fc_initiator)

        try:
            self.assign_fc_vdev(client_id, vid)
            time.sleep(3)
        except FSSHTTPError as err:
            with excutils.save_and_reraise_exception() as ctxt:
                if (err.code == 2415984845 and "XML_ERROR_CLIENT_EXIST"
                                               in err.text):
                    ctxt.reraise = False
                LOG.warning(_LW('Assign volume failed with message: %(msg)s.'),
                            {"msg": err.reason})
        finally:
            lun = self.FSS._get_fc_client_info(client_id, vid)

            fc_target_info['lun'] = lun
            fc_target_info['available_initiator'] = available_initiator

        if not fc_target_info:
            msg = _('Failed to get iSCSI target info for the LUN: %s.')
            raise exception.VolumeBackendAPIException(data=msg % volume_name)
        return fc_target_info

    def fc_terminate_connection(self, volume, connector):
        client_id = 0
        volume_name = self._get_fss_volume_name(volume)
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        output = self.list_volume_info(vid)
        if 'data' not in output:
            msg = _('No vdev information in given data')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'clients' not in output['data']:
            msg = _('No clients in vdev information.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        client_info = output['data']['clients']
        for fcclients in client_info:
            client_id = int(fcclients['id'])

        if client_id == 0:
            msg = _(
                'Can not find client id. The connection target name is %s.')
            raise exception.VolumeBackendAPIException(
                data=msg % connector["initiator"])
        try:
            self.unassign_vdev(client_id, vid)
        except FSSHTTPError as err:
            with excutils.save_and_reraise_exception() as ctxt:
                if (err.code == 2415984988 and
                        "XML_ERROR_VIRTUAL_DEV_NOT_ASSIGNED_TO_iSCSI_TARGET"
                        in err.text):
                    ctxt.reraise = False
                LOG.warning(_LW('Disconnection failed with message: '
                                "%(msg)s."), {"msg": err.reason})
        return client_id

    def initialize_connection_iscsi(self, volume, connector, fss_hosts):
        """Connect the host and volume; return dict describing connection."""
        vid = 0
        iscsi_target_info = {}
        self._check_iscsi_option()
        client_id, target_id = self._get_iscsi_host(connector)

        if target_id is None:
            initiator = connector["initiator"]
            host_name = GROUP_PREFIX + '%s-' % connector["host"]

            initiator_info = initiator.split(':')
            idx = len(initiator_info) - 1
            client_host_name = host_name + initiator_info[idx]

            client_id, target_id = self._create_iscsi_host(client_host_name,
                                                           initiator,
                                                           fss_hosts)
        volume_name = self._get_fss_volume_name(volume)
        try:
            vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
            if not vid:
                msg = (_('Can not find cinder volume - %(volumeName)s.') %
                       {"volumeName": volume_name})
                raise exception.VolumeBackendAPIException(msg)

            self.assign_iscsi_vdev(client_id, target_id, vid)
            time.sleep(3)
        except FSSHTTPError as err:
            with excutils.save_and_reraise_exception() as ctxt:
                if (err.code == 2415984989 and
                        "XML_ERROR_VIRTUAL_DEV_ASSIGNED_TO_iSCSI_TARGET" in
                        err.text):
                    ctxt.reraise = False
                LOG.warning(_LW("Assign volume failed with message: %(msg)s."),
                            {"msg": err.reason})
        finally:
            (lun, target_name) = self.FSS._get_iscsi_target_info(client_id,
                                                                 vid)
            iscsi_target_info['lun'] = lun
            iscsi_target_info['iqn'] = target_name

        if not iscsi_target_info:
            msg = _('Failed to get iSCSI target info for the LUN: %s')
            raise exception.VolumeBackendAPIException(data=msg % volume_name)
        return iscsi_target_info

    def terminate_connection_iscsi(self, volume, connector):
        volume_name = self._get_fss_volume_name(volume)
        vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
        client_id, target_id = self._get_iscsi_host(connector)
        if not client_id:
            msg = _('Can not find client id. The connection target name '
                    'is %s.')
            raise exception.VolumeBackendAPIException(
                data=msg % connector["initiator"])
        try:
            self.unassign_vdev(client_id, vid)
        except FSSHTTPError as err:
            with excutils.save_and_reraise_exception() as ctxt:
                if (err.code == 2415984988 and
                        "XML_ERROR_VIRTUAL_DEV_NOT_ASSIGNED_TO_iSCSI_TARGET"
                        in err.text):
                    ctxt.reraise = False
                LOG.warning(_LW("Disconnection failed with message: "
                                "%(msg)s."), {"msg": err.reason})
        finally:
            is_empty = self.FSS._check_host_mapping_status(client_id,
                                                           target_id)

            if is_empty:
                self.FSS.delete_iscsi_target(target_id)
                self.FSS.delete_client(client_id)

    def _get_existing_volume_ref_vid(self, existing_ref):
        if 'source-id' in existing_ref:
            vid = existing_ref['source-id']
        else:
            reason = _("FSSISCSIDriver manage_existing requires vid to "
                       "identify an existing volume.")
            raise exception.ManageExistingInvalidReference(
                existing_ref=existing_ref, reason=reason)
        vdev_info = self.list_volume_info(vid)
        if not vdev_info:
            raise exception.ManageExistingInvalidReference(
                existing_ref=existing_ref,
                reason=_("Unable to find volume with FSS vid =%s.") % vid)

        if 'data' not in vdev_info:
            msg = _('No vdev information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'sizemb' not in vdev_info['data']:
            msg = _('No vdev sizemb in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        return vdev_info['data']['sizemb']

    def _manage_existing_volume(self, vid, volume):
        new_vol_name = self._get_fss_volume_name(volume)
        try:
            self.rename_vdev(vid, new_vol_name)
        except FSSHTTPError as err:
            with excutils.save_and_reraise_exception() as ctxt:
                ctxt.reraise = False
            LOG.warning(_LW("Volume manage_existing_volume was unable "
                            "to rename the volume, error message: %s."),
                        err.reason)

    def unmanage(self, volume):
        volume_name = self._get_fss_volume_name(volume)
        unmanaged_vol_name = volume_name + "-unmanaged"
        try:
            vid = self._get_fss_vid_from_name(volume_name, FSS_SINGLE_TYPE)
            self.rename_vdev(vid, unmanaged_vol_name)
        except FSSHTTPError as err:
            LOG.warning(_LW("Volume unmanage was unable to rename the volume,"
                            " error message: %(msg)s."), {"msg": err.reason})


class FSSRestCommon(object):
    def __init__(self, host, username, password, fss_debug):
        self.hostip = host
        self.username = username
        self.password = password
        self.session_id = None
        self.fss_debug = fss_debug

    def _fss_request(self, method, path, data=None):
        json_data = None
        url = "http://%(ip)s/%(product)s/%(path)s" % {
            "ip": self.hostip, "product": PRODUCT_NAME, "path": path}
        headers = {"Content-Type": "application/json"}
        if self.session_id is not None:
            cookie = dict(
                Cookie=SESSION_COOKIE_NAME + '=' + self.session_id
            )
            headers.update(cookie)

        if data is not None:
            request_body = json.dumps(data).encode("utf-8")
        else:
            request_body = None

        connection = http_client.HTTPConnection(self.hostip, 80, timeout=60)

        if self.fss_debug:
            LOG.info(_LI("[FSS_RESTAPI]====%(method)s@url=%(url)s ===="
                         "@request_body=%(body)s===") % {
                     "method": method,
                     "url": url,
                     "body": request_body})

        attempt = 1
        while True:
            connection.request(method, url, request_body, headers)
            response = connection.getresponse()
            response_body = response.read()
            if response_body:
                try:
                    data = json.loads(response_body)
                    json_data = json.dumps(data)
                    json_data = json.loads(json_data.decode('utf8'))
                except ValueError:
                    pass

            if self.fss_debug:
                LOG.info(_LI("[FSS_RESTAPI]==@json_data: %s =="), json_data)

            if response.status == 200:
                return json_data
            elif response.status == 404:
                msg = (_('FSS rest api return failed, method=%(method)s, '
                         'uri=%(url)s, response=%(response)s') % {
                       "method": method,
                       "url": url,
                       "response": response_body})
                raise exception.VolumeBackendAPIException(msg)
            else:
                err_code = json_data['rc']
                if (attempt > RETRY_CNT) or (str(err_code) not in RETRY_LIST):
                    err_target = ("method=%(method)s, url=%(url)s, "
                                  "response=%(response)s" %
                                  {"method": method, "url": url,
                                   "response": response_body})
                    err_response = self.get_fss_error_code(err_code)
                    err = dict(
                        code=err_code,
                        text=err_response['key'],
                        reason=err_response['message']
                    )
                    raise FSSHTTPError(err_target, err)
                attempt += 1
                LOG.warning(_LW("Retry with rc: %s."), err_code)
                self._random_sleep(RETRY_INTERVAL)
                if err_code == 107:
                    self.fss_login()

    def _random_sleep(self, interval=60):
        nsleep = random.randint(10, interval * 10)
        value = round(float(nsleep) / 10, 2)
        time.sleep(value)

    #
    # REST API session management methods
    #
    def fss_login(self):
        url = '%s/%s' % (FSS_AUTH, FSS_LOGIN)
        params = dict(
            username=self.username,
            password=self.password,
            server=self.hostip
        )
        data = self._fss_request(POST, url, params)
        if 'id' in data:
            self.session_id = data['id']
        return self.session_id

    #
    # Physical Adapters management methods
    #

    def list_physicaladapter_info(self, adapter_id=None):
        url = '%s/%s' % (FSS_PHYSICALRESOURCE, FSS_PHYSICALADAPTER)
        if adapter_id is not None:
            url = '%s/%s/%s' % (FSS_PHYSICALRESOURCE,
                                FSS_PHYSICALADAPTER, adapter_id)
        return self._fss_request(GET, url)

    def list_fc_target_wwpn(self):
        url = '%s/%s/%s' % (FSS_PHYSICALRESOURCE, FSS_PHYSICALADAPTER,
                            FSS_FC_TGT_WWPN)
        tgt_wwpn = []
        output = self._fss_request(GET, url)
        if output['data']:
            tgt_wwpns = output['data']
            for tgt_alias_wwpn in tgt_wwpns:
                tgt_wwpn.append(
                    str(tgt_alias_wwpn['aliaswwpn'].replace('-', '')))
        return tgt_wwpn

    def list_fc_client_initiators(self):
        url = '%s/%s/%s' % (FSS_PHYSICALRESOURCE, FSS_PHYSICALADAPTER,
                            FSS_FCCLIENTINITIATORS)
        return self._fss_request(GET, url)

    #
    # storage pool management methods
    #

    def list_pool_info(self, pool_id=None):
        url = '%s/%s' % (FSS_PHYSICALRESOURCE, FSS_STORAGE_POOL)
        if pool_id is not None:
            url = '%s/%s/%s' % (FSS_PHYSICALRESOURCE,
                                FSS_STORAGE_POOL, pool_id)
        return self._fss_request(GET, url)

    #
    # Volume and snapshot management methods
    #

    def create_vdev(self, params):
        metadata = {}
        url = '%s/%s' % (FSS_LOGICALRESOURCE, FSS_SAN)
        output = self._fss_request(POST, url, params)
        if output:
            if output['rc'] == 0:
                metadata['FSS-vid'] = output['id']
        return metadata

    def _check_mirror_sync_finished(self, vid, timeout):
        starttime = time.time()
        while True:
            self._random_sleep()
            if time.time() > starttime + timeout:
                msg = (_('FSS get mirror sync timeout on vid: %s ') % vid)
                raise exception.VolumeBackendAPIException(data=msg)
            elif self._check_mirror_sync_status(vid):
                break

    def delete_vdev(self, vid):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SAN, vid)
        return self._fss_request(DELETE, url, dict(force=True))

    def extend_vdev(self, vid, params):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SAN, vid)
        return self._fss_request(PUT, url, params)

    def rename_vdev(self, vid, params):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SAN, vid)
        return vid, self._fss_request(PUT, url, params)

    def list_fss_volume_info(self, vid=None):
        url = '%s/%s' % (FSS_LOGICALRESOURCE, FSS_SAN)
        if vid is not None:
            url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SAN, vid)
        return self._fss_request(GET, url)

    def _get_fss_vid_from_name(self, volume_name, fss_type=None):
        vid = []
        output = self.list_fss_volume_info()
        try:
            if "virtualdevices" in output['data']:
                for item in output['data']['virtualdevices']:
                    if item['name'] in volume_name:
                        vid.append(item['id'])
        except Exception:
            msg = (_('Can not find cinder volume - %s') % volume_name)
            raise exception.VolumeBackendAPIException(msg)

        if fss_type is not None and fss_type == FSS_SINGLE_TYPE:
            vid = ''.join(str(x) for x in vid)
        return vid

    def _check_if_snapshot_tm_exist(self, vid):
        snapshotenabled = False
        timemarkenabled = False
        sizemb = 0
        output = self.list_fss_volume_info(vid)
        if "snapshotenabled" in output['data']:
            snapshotenabled = output['data']['snapshotenabled']
        if "timemarkenabled" in output['data']:
            timemarkenabled = output['data']['timemarkenabled']
        if "sizemb" in output['data']:
            sizemb = output['data']['sizemb']
        return (snapshotenabled, timemarkenabled, sizemb)

    def create_vdev_snapshot(self, params):
        url = '%s/%s/%s' % (FSS_BATCH, FSS_LOGICALRESOURCE,
                            FSS_SNAPSHOT_RESOURCE)
        return self._fss_request(POST, url, params)

    def create_timemark_policy(self, vid, **kwargs):
        url = '%s/%s/%s' % (FSS_BATCH, FSS_LOGICALRESOURCE, FSS_TIMEMARKPOLICY)
        params = dict(
            idlist=[vid],
            automatic=dict(enabled=False),
            maxtimemarkcount=MAXSNAPSHOTS
        )
        if kwargs.get('storagepoolid'):
            params.update(kwargs)
        return self._fss_request(POST, url, params)

    def create_timemark(self, vid, snap_name):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_TIMEMARK, vid)
        params = dict(
            comment=snap_name,
            priority='medium',
            snapshotnotification=False
        )
        return self._fss_request(POST, url, params)

    def get_timemark(self, vid):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_TIMEMARK, vid)
        return self._fss_request(GET, url)

    def delete_timemark(self, timestamp):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_TIMEMARK, timestamp)
        params = dict(
            deleteallbefore=False
        )
        return self._fss_request(DELETE, url, params)

    def delete_timemark_policy(self, vid):
        url = '%s/%s/%s' % (FSS_BATCH, FSS_LOGICALRESOURCE, FSS_TIMEMARKPOLICY)
        params = dict(
            idlist=[vid]
        )
        return self._fss_request(DELETE, url, params)

    def delete_vdev_snapshot(self, vid):
        url = '%s/%s/%s' % (FSS_BATCH, FSS_LOGICALRESOURCE,
                            FSS_SNAPSHOT_RESOURCE)
        params = dict(
            idlist=[vid]
        )
        return self._fss_request(DELETE, url, params)

    def copy_timemark(self, timestamp, **kwargs):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_TIMEMARK, timestamp)
        params = dict(
            action='copy',
            includetimeviewdata=False
        )
        params.update(kwargs)
        return self._fss_request(PUT, url, params)

    def get_timemark_copy_status(self, vid):
        url = '%s/%s/%s?type=operationstatus' % (
            FSS_LOGICALRESOURCE, FSS_TIMEMARK, vid)
        return self._fss_request(GET, url)

    def _check_tm_copy_status(self, vid):
        finished = False
        output = self.get_timemark_copy_status(vid)
        if output['timemarkoperationstatus']:
            timemark_status = output['timemarkoperationstatus']
            if timemark_status['operation'] == "copy":
                if timemark_status['status'] == 'completed':
                    finished = True
        return finished

    def _check_tm_copy_finished(self, vid, timeout):
        finished = False
        starttime = time.time()
        while True:
            self._random_sleep()
            if time.time() > starttime + timeout:
                msg = (_('FSS get timemark copy timeout on vid: %s') % vid)
                raise exception.VolumeBackendAPIException(data=msg)
            elif self._check_tm_copy_status(vid):
                finished = True
                return finished

    #
    # TimeView methods
    #

    def create_timeview(self, tv_vid, params):
        vid = ''
        volume_metadata = {}
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_TIMEVIEW, tv_vid)
        output = self._fss_request(POST, url, params)
        if output and output['rc'] == 0:
            if output['copyid'] == -1:
                vid = output['id']
            else:
                vid = output['copyid']
        volume_metadata['FSS-vid'] = vid
        return volume_metadata

    #
    # Mirror methods
    #

    def create_mirror(self, vid, pool_id):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_MIRROR, vid)
        params = dict(
            category='virtual',
            selectioncriteria='anydrive',
            mirrortarget="virtual"
        )
        params.update(pool_id)
        return self._fss_request(POST, url, params)

    def get_mirror_sync_status(self, vid):
        url = '%s/%s/%s?type=syncstatus' % (
            FSS_LOGICALRESOURCE, FSS_MIRROR, vid)
        return self._fss_request(GET, url)

    def _check_mirror_sync_status(self, vid):
        finished = False
        output = self.get_mirror_sync_status(vid)
        if output['mirrorsyncstatus']:
            mirrorsyncstatus = output['mirrorsyncstatus']
            if mirrorsyncstatus['status'] == "insync":
                if mirrorsyncstatus['percentage'] == 0:
                    finished = True
        return finished

    def _set_mirror(self, vid, **kwargs):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_MIRROR, vid)
        return self._fss_request(PUT, url, kwargs)

    def sync_mirror(self, vid):
        return self._set_mirror(vid, action='sync')

    def promote_mirror(self, vid, new_volume_name):
        return self._set_mirror(vid, action='promote', name=new_volume_name)

    #
    # Host management methods
    #

    def get_server_options(self):
        url = '%s/%s' % (FSS_SERVER, FSS_OPTIONS)
        return self._fss_request(GET, url)

    def set_server_options(self, action):
        url = '%s/%s' % (FSS_SERVER, FSS_OPTIONS)
        params = dict(
            action=action,
            enabled=True
        )
        return self._fss_request(PUT, url, params)

    def get_server_name(self):
        url = '%s/%s' % (FSS_SERVER, FSS_OPTIONS)
        return self._fss_request(GET, url)

    #
    # SAN Client management methods
    #

    def list_client_initiators(self):
        url = '%s/%s/%s' % (FSS_CLIENT, FSS_SANCLIENT,
                            FSS_ISCSI_CLIENT_INITIATORS)
        return self._fss_request(GET, url)

    def get_default_portal(self):
        url = '%s/%s/%s' % (FSS_SERVER, FSS_OPTIONS, FSS_PORTAL)
        return self._fss_request(GET, url)

    def create_client(self, params):
        url = '%s/%s' % (FSS_CLIENT, FSS_SANCLIENT)
        return self._fss_request(POST, url, params)

    def list_sanclient_info(self, client_id=None):
        url = '%s/%s' % (FSS_CLIENT, FSS_SANCLIENT)
        if client_id is not None:
            url = '%s/%s/%s' % (FSS_CLIENT, FSS_SANCLIENT,
                                client_id)
        return self._fss_request(GET, url)

    def assign_vdev(self, client_id, params):
        url = '%s/%s/%s' % (FSS_CLIENT, FSS_SANCLIENT, client_id)
        return self._fss_request(PUT, url, params)

    def unassign_vdev(self, client_id, params):
        url = '%s/%s/%s' % (FSS_CLIENT, FSS_SANCLIENT, client_id)
        return self._fss_request(PUT, url, params)

    def _get_iscsi_target_info(self, client_id, vid):
        lun = 0
        target_name = None
        output = self.list_sanclient_info(client_id)

        if 'data' not in output:
            msg = _('No target information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'iscsidevices' not in output['data']:
            msg = _('No iscsidevices information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        for iscsidevices in output['data']['iscsidevices']:
            if int(vid) == int(iscsidevices['id']):
                lun = iscsidevices['lun']
                iscsitarget_info = iscsidevices['iscsitarget']
                for key, value in iscsitarget_info.items():
                    if key == 'name':
                        target_name = value

        return lun, target_name

    def _check_host_mapping_status(self, client_id, target_id):
        is_empty = False
        hosting_cnt = 0
        output = self.list_sanclient_info(client_id)
        if 'data' not in output:
            msg = _('No target in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'iscsidevices' not in output['data']:
            msg = _('No iscsidevices information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        if len(output['data']['iscsidevices']) == 0:
            is_empty = True
        else:
            for iscsidevices in output['data']['iscsidevices']:
                iscsitarget_info = iscsidevices['iscsitarget']
                for key, value in iscsitarget_info.items():
                    if key == 'id' and target_id == value:
                        hosting_cnt += 1

            if hosting_cnt == 0:
                is_empty = True
        return is_empty

    def list_iscsi_target_info(self, target_id=None):
        url = '%s/%s' % (FSS_CLIENT, FSS_ISCSI_TARGET)
        if target_id is not None:
            url = '%s/%s/%s' % (FSS_CLIENT, FSS_ISCSI_TARGET,
                                target_id)
        return self._fss_request(GET, url)

    def _get_iscsi_target_id(self, initiator_iqn):
        target_id = ''
        client_id = ''
        output = self.list_iscsi_target_info()

        if 'data' not in output:
            msg = _('No target in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'iscsitargets' not in output['data']:
            msg = _('No iscsitargets for target.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        for targets in output['data']['iscsitargets']:
            if 'name' in targets:
                if initiator_iqn in targets['name']:
                    target_id = str(targets['id'])
                    client_id = str(targets['clientid'])
                    break
        return target_id, client_id

    def create_iscsitarget(self, params):
        url = '%s/%s' % (FSS_CLIENT, FSS_ISCSI_TARGET)
        return self._fss_request(POST, url, params)

    def delete_iscsi_target(self, target_id):
        url = '%s/%s/%s' % (FSS_CLIENT, FSS_ISCSI_TARGET, target_id)
        params = dict(
            force=True
        )
        return self._fss_request(DELETE, url, params)

    def delete_client(self, client_id):
        url = '%s/%s/%s' % (FSS_CLIENT, FSS_SANCLIENT, client_id)
        return self._fss_request(DELETE, url)

    def _get_fc_client_info(self, client_id, vid):
        lun = 0
        output = self.list_sanclient_info(client_id)
        if 'data' not in output:
            msg = _('No target information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)
        if 'fcdevices' not in output['data']:
            msg = _('No fcdevices information in given data.')
            LOG.error(msg)
            raise exception.VolumeBackendAPIException(data=msg)

        for fcdevices in output['data']['fcdevices']:
            if int(vid) == int(fcdevices['id']):
                lun = fcdevices['lun']

        return lun

    #
    # Group related methods
    #

    def create_group(self, params):
        url = '%s/%s' % (FSS_LOGICALRESOURCE, FSS_SNAPSHOT_GROUP)
        return self._fss_request(POST, url, params)

    def list_group_info(self, gid=None):
        if gid is not None:
            url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SNAPSHOT_GROUP, gid)
        else:
            url = '%s/%s' % (FSS_LOGICALRESOURCE, FSS_SNAPSHOT_GROUP)
        return self._fss_request(GET, url)

    def set_group(self, gid, join_params=None, leave_params=None):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SNAPSHOT_GROUP, gid)
        if join_params:
            self._fss_request(PUT, url, join_params)
        if leave_params:
            self._fss_request(PUT, url, leave_params)

    def create_group_timemark_policy(self, gid, params):
        url = '%s/%s/%s/%s' % (FSS_LOGICALRESOURCE,
                               FSS_SNAPSHOT_GROUP, FSS_TIMEMARKPOLICY, gid)
        return self._fss_request(POST, url, params)

    def _check_if_group_tm_enabled(self, gid):
        timemarkenabled = False
        output = self.list_group_info(gid)
        if "timemarkenabled" in output['data']:
            timemarkenabled = output['data']['timemarkenabled']
        return timemarkenabled

    def create_group_timemark(self, gid, params):
        url = '%s/%s/%s/%s' % (FSS_LOGICALRESOURCE,
                               FSS_SNAPSHOT_GROUP, FSS_TIMEMARK, gid)
        return self._fss_request(POST, url, params)

    def get_group_timemark(self, gid):
        url = '%s/%s/%s/%s' % (FSS_LOGICALRESOURCE,
                               FSS_SNAPSHOT_GROUP, FSS_TIMEMARK, gid)
        return self._fss_request(GET, url)

    def delete_group_timemark(self, timestamp, params):
        url = '%s/%s/%s/%s' % (FSS_LOGICALRESOURCE,
                               FSS_SNAPSHOT_GROUP, FSS_TIMEMARK, timestamp)
        return self._fss_request(DELETE, url, params)

    def delete_group_timemark_policy(self, gid):
        url = '%s/%s/%s/%s' % (FSS_LOGICALRESOURCE,
                               FSS_SNAPSHOT_GROUP, FSS_TIMEMARKPOLICY, gid)
        return self._fss_request(DELETE, url)

    def delete_snapshot_group(self, gid):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SNAPSHOT_GROUP, gid)
        return self._fss_request(DELETE, url)

    def destroy_group(self, gid):
        url = '%s/%s/%s' % (FSS_LOGICALRESOURCE, FSS_SNAPSHOT_GROUP, gid)
        return self._fss_request(DELETE, url)

    def get_fss_error_code(self, err_id):
        try:
            url = '%s/%s/%s' % (FSS_SERVER, FSS_RETURN_CODE, err_id)
            output = self._fss_request(GET, url)
            if output['rc'] == 0:
                return output
        except Exception:
            msg = (_('Can not find this error code:%s.') % err_id)
            raise exception.APIException(reason=msg)


class FSSHTTPError(Exception):

    def __init__(self, target, response):
        super(FSSHTTPError, self).__init__()
        self.target = target
        self.code = response['code']
        self.text = response['text']
        self.reason = response['reason']

    def __str__(self):
        msg = ("FSSHTTPError code {0} returned by REST at {1}: {2}\n{3}")
        return msg.format(self.code, self.target,
                          self.reason, self.text)
