Fetched from 

http://www.fujitsu.com/global/support/products/computing/storage/disk/download/openstack-vd-download.html

(P2X0-1320-03ENZ0 / July 2014)

Index: cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_common.py
===================================================================
--- /dev/null
+++ cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_common.py
@@ -0,0 +1,2985 @@
+﻿# Copyright (c) 2014 FUJITSU LIMITED
+# Copyright (c) 2012 EMC Corporation.
+# Copyright (c) 2012 OpenStack Foundation
+# 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.
+#
+
+'''
+Cinder Volume driver for Fujitsu ETERNUS DX S2 and S3 series.
+'''
+
+##------------------------------------------------------------------------------------------------##
+##                                                                                                ##
+##  ETERNUS OpenStack Volume Driver                                                               ##
+##                                                                                                ##
+##  Note      :                                                                                   ##
+##  File Name : fujitsu_eternus_dx_common.py                                                      ##
+##  Copyright 2014 FUJITSU LIMITED                                                                ##
+##                                                                                                ##
+##  history :                                                                                     ##
+##      2014.03 : 1.0.0 : volume(create,delete,attach,detach,create from snapshot)                ##
+##                        snapshot(create,delete)                                                 ##
+##      2014.04 : 1.0.1 : Fix comment                                                             ##
+##      2014.06 : 1.1.0 : Support 4 features                                                      ##
+##                         Extend Volume                                                          ##
+##                         Clone Volume                                                           ##
+##                         Copy Image to Volume                                                   ##
+##                         Copy Volume to Image                                                   ##
+##------------------------------------------------------------------------------------------------##
+
+
+import time
+import hashlib
+import base64
+from oslo.config import cfg
+from xml.dom.minidom import *
+from xml.etree.ElementTree import *
+from cinder import exception
+from cinder.openstack.common import lockutils
+from cinder.openstack.common import log as logging
+
+LOG = logging.getLogger(__name__)
+
+try:
+    import pywbem
+except:
+    LOG.error(_('import pywbem failed!!'
+               'pywbem is necessary for this volume driver.'))
+
+#**************************************************************************************************#
+CONF                   = cfg.CONF
+VOL_PREFIX             = "FJosv_"
+RAIDGROUP              = 2
+TPPOOL                 = 5
+SNAPOPC                = 4
+OPC                    = 5
+RETURN_TO_RESOURCEPOOL = 19
+DETACH                 = 8
+INITIALIZED            = 2
+UNSYNCHRONIZED         = 3
+BROKEN                 = 5
+PREPARED               = 11
+REPL                   = "FUJITSU_ReplicationService"
+STOR_CONF              = "FUJITSU_StorageConfigurationService"
+CTRL_CONF              = "FUJITSU_ControllerConfigurationService"
+STOR_HWID              = "FUJITSU_StorageHardwareIDManagementService"
+
+#**************************************************************************************************#
+FJ_ETERNUS_DX_OPT_list = [cfg.StrOpt('cinder_eternus_config_file',
+                                default='/etc/cinder/cinder_fujitsu_eternus_dx.xml',
+                                help='config file for cinder fujitsu_eternus_dx volume driver')]
+
+#**************************************************************************************************#
+POOL_TYPE_dic          = {RAIDGROUP:'RAID_GROUP',
+                          TPPOOL   :'Thinporvisioning_POOL'
+                          }
+
+OPERATION_dic          = {SNAPOPC:RETURN_TO_RESOURCEPOOL,
+                          OPC    :DETACH
+                          }
+
+RETCODE_dic            = {'0'    :'Success',
+                          '1'    :'Method Not Supported',
+                          '4'    :'Failed',
+                          '5'    :'Invalid Parameter',
+                          '4097' :'Size Not Supported',
+                          '32769':'Maximum number of Logical Volume in'
+                                  ' a RAID group has been reached',
+                          '32770':'Maximum number of Logical Volume in'
+                                  ' the storage device has been reached',
+                          '32771':'Maximum number of registered Host WWN'
+                                  ' has been reached',
+                          '32772':'Maximum number of affinity group has been reached',
+                          '32773':'Maximum number of host affinity has been reached',
+                          '32785':'The RAID group is in busy state',
+                          '32786':'The Logical Volume is in busy state',
+                          '32787':'The device is in busy state',
+                          '32788':'Element Name is in use',
+                          '32792':'No Copy License',
+                          '32796':'Quick Format Error',
+                          '32801':'The CA port is in invalid setting',
+                          '32802':'The Logical Volume is Mainframe volume',
+                          '32803':'The RAID group is not operative',
+                          '32804':'The Logical Volume is not operative',
+                          '32808':'No Thin Provisioning License',
+                          '32809':'The Logical Element is ODX volume',
+                          '32811':'This operation cannot be performed to the NAS resources',
+                          '32812':'This operation cannot be performed to the Storage'
+                                  ' Cluster resources',
+                          '32816':'Fatal error generic',
+                          '35302':'Invalid LogicalElement',
+                          '35304':'LogicalElement state error',
+                          '35316':'Multi-hop error',
+                          '35318':'Maximum number of multi-hop has been reached',
+                          '35324':'RAID is broken',
+                          '35331':'Maximum number of session has been reached(per device)',
+                          '35333':'Maximum number of session has been reached(per SourceElement)',
+                          '35334':'Maximum number of session has been reached(per TargetElement)',
+                          '35335':'Maximum number of Snapshot generation has been'
+                                  ' reached (per SourceElement)',
+                          '35346':'Copy table size is not setup',
+                          '35347':'Copy table size is not enough'
+                          }
+
+#**************************************************************************************************#
+
+#--------------------------------------------------------------------------------------------------#
+# Class : FJDXCommon                                                                               #
+#         summary      : cinder volume driver for Fujitsu ETERNUS DX                               #
+#--------------------------------------------------------------------------------------------------#
+class FJDXCommon(object):
+    '''
+    Common code that does not depend on protocol.
+    '''
+
+    # initialize
+    stats = {'driver_version': '1.1',
+             'free_capacity_gb': 0,
+             'reserved_percentage': 0,
+             'storage_protocol': None,
+             'total_capacity_gb': 0,
+             'vendor_name': 'FUJITSU',
+             'QoS_support': False,
+             'volume_backend_name': None}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : __init__                                                                            #
+    #         summary      :                                                                       #
+    #         parameters   :                                                                       #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def __init__(self, prtcl, configuration=None):
+        '''
+        Constructor
+        '''
+        self.protocol      = prtcl
+        self.configuration = configuration
+        self.configuration.append_config_values(FJ_ETERNUS_DX_OPT_list)
+
+        if prtcl == 'iSCSI':
+            # get iSCSI ipaddress from driver configuration file
+            self.configuration.iscsi_ip_address = self._get_drvcfg('EternusISCSIIP')
+        # end of if
+        self.conn = self._get_eternus_connection()
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_volume                                                                       #
+    #         summary      : create volume on ETERNUS                                              #
+    #         parameters   : volume                                                                #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def create_volume(self, volume):
+        '''
+        create volume on ETERNUS
+        '''
+        # volumesize   : volume size Byte
+        # volumename   : volumename on ETERNUS
+        # eternus_pool : poolname
+        # pool         : pool instance
+        # pooltype     : RAID(2) or TPP(5)
+        # configservice: FUJITSU_StorageConfigurationService
+        # msg          : message
+        # rc           : result of invoke method
+        # errordesc    : error message
+        # job          : unused
+
+        LOG.debug(_('*****create_volume,Enter method'))
+
+        # initialize
+        systemnamelist = None
+        volumesize     = 0
+        volumename     = None
+        eternus_pool   = None
+        pool           = None
+        pooltype       = 0
+        configservice  = None
+        msg            = None
+        rc             = 0
+        errordesc      = None
+        job            = None
+
+        # main processing
+        # conversion of the unit. GB to B
+        volumesize = int(volume['size']) * 1073741824
+
+        # create to volumename on ETERNUS from cinder VolumeID
+        volumename = self._create_volume_name(volume['id'])
+        LOG.debug(_('*****create_volume,volumename:%(volumename)s,'
+                    'volumesize:%(volumesize)u')
+                   % {'volumename': volumename,
+                      'volumesize': volumesize})
+
+        self.conn = self._get_eternus_connection()
+
+        # get poolname from driver configuration file
+        eternus_pool = self._get_drvcfg('EternusPool')
+        # Existence check the pool
+        pool = self._find_pool(eternus_pool)
+        if pool is None:
+            msg = (_('create_volume,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'not found.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # set pooltype
+        if 'RSP' in pool['InstanceID']:
+            pooltype = RAIDGROUP
+        else:
+            pooltype = TPPOOL
+        # end of if
+
+        configservice = self._find_eternus_service(STOR_CONF)
+        if configservice is None:
+            msg = (_('create_volume,volume:%(volume)s,'
+                     'volumename:%(volumename)s,'
+                     'eternus_pool:%(eternus_pool),'
+                     'Error!! Storage Configuration Service is None.')
+                    % {'volume':volume,
+                       'volumename': volumename,
+                       'eternus_pool':eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+        LOG.debug(_('*****create_volume,CreateOrModifyElementFromStoragePool,'
+                    'ConfigService:%(service)s,'
+                    'ElementName:%(volumename)s,'
+                    'InPool:%(eternus_pool)s,'
+                    'ElementType:%(pooltype)u,'
+                    'Size:%(volumesize)u')
+                   % {'service':configservice,
+                      'volumename': volumename,
+                      'eternus_pool':eternus_pool,
+                      'pooltype':pooltype,
+                      'volumesize': volumesize})
+
+        # Invoke method for create volume
+        rc, errordesc, job = self._exec_eternus_service(
+            'CreateOrModifyElementFromStoragePool',
+            configservice,
+            ElementName=volumename,
+            InPool=pool,
+            ElementType=pywbem.Uint16(pooltype),
+            Size=pywbem.Uint64(volumesize))
+
+        if rc != 0L:
+            msg = (_('create_volume,'
+                     'volumename:%(volumename)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s')
+                    % {'volumename': volumename,
+                       'rc': rc,
+                       'errordesc':errordesc})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # get eternus model for metadata
+        # systemname = systemnamelist[0]['IdentifyingNumber']
+        # ex) ET092DC4511133A10
+        try:
+            systemnamelist = self.conn.EnumerateInstances(
+                'FUJITSU_StorageProduct')
+        except:
+            msg=(_('create_volume,'
+                   'volume:%(volume)s,'
+                   'EnumerateInstances,'
+                   'cannot connect to ETERNUS.')
+                  % {'volume':volume})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        LOG.debug(_('*****create_volume,'
+                    'volumename:%(volumename)s,'
+                    'Return code:%(rc)lu,'
+                    'Error:%(errordesc)s,'
+                    'Backend:%(backend)s,'
+                    'Pool Name:%(eternus_pool)s,'
+                    'Pool Type:%(pooltype)s,'
+                    'Leaving create_volume')
+                   % {'volumename': volumename,
+                      'rc': rc,
+                      'errordesc':errordesc,
+                      'backend':systemnamelist[0]['IdentifyingNumber'],
+                      'eternus_pool':eternus_pool,
+                      'pooltype':POOL_TYPE_dic[pooltype]})
+
+        return {'FJ_Backend':systemnamelist[0]['IdentifyingNumber'],
+                'FJ_Volume_Name':volumename,
+                'FJ_Pool_Name':eternus_pool,
+                'FJ_Pool_Type':POOL_TYPE_dic[pooltype]}
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_volume_from_snapshot                                                         #
+    #         summary      : create volume from snapshot                                           #
+    #         parameters   : volume, snapshot                                                      #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def create_volume_from_snapshot(self, volume, snapshot):
+        '''
+        Creates a volume from a snapshot
+        '''
+        # sysnames              : FUJITSU_SrogareProduct
+        # backend               : ETERNUS model
+        # snapshotname          : snapshotname on OpenStack
+        # t_volumename          : target volumename on ETERNUS
+        # s_volumename          : source volumename on ETERNUS
+        # eternus_pool          : poolname
+        # pool                  : pool instance
+        # pooltype              : RAID(2) or TPP(5)
+        # configservice         : FUJITSU_StorageConfigurationService
+        # source_volume_instance: snapshot instance
+        # target_volume_instance: target volume instance
+        # msg                   : message
+        # rc                    : result of invoke method
+        # errordesc             : error message
+        # job                   : unused
+
+        LOG.debug(_('*****create_volume_from_snapshot,Enter method'))
+
+        # initialize
+        systemnamelist           = None
+        systemname               = None
+        snapshotname             = None
+        t_volumename             = None
+        s_volumename             = None
+        eternus_pool             = None
+        pool                     = None
+        pooltype                 = 0
+        repservice               = None
+        source_volume_instance   = None
+        target_volume_instance   = None
+        msg                      = None
+        rc                       = 0
+        errordesc                = None
+        job                      = None
+
+        # main processing
+        snapshotname           = snapshot['name']
+        t_volumename           = self._create_volume_name(volume['id'])
+        s_volumename           = self._create_volume_name(snapshot['id'])
+        self.conn              = self._get_eternus_connection()
+        source_volume_instance = self._find_lun(s_volumename)
+
+        # Existence check the source volume
+        if source_volume_instance is None:
+            msg=(_('create_volume_from_snapshot,'
+                   'Source Volume is not exist in ETERNUS.'))
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        # create volume for destination of cloned volume
+        self.create_volume(volume)
+        target_volume_instance = self._find_lun(t_volumename)
+
+        # get eternus model for metadata
+        # systemname = systemnamelist[0]['IdentifyingNumber']
+        # ex) ET092DC4511133A10
+        try:
+            systemnamelist = self.conn.EnumerateInstances(
+                'FUJITSU_StorageProduct')
+        except:
+            msg=(_('create_volume_from_snapshot,'
+                   'volume:%(volume)s,'
+                   'EnumerateInstances,'
+                   'cannot connect to ETERNUS.')
+                  % {'volume':volume})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        systemname = systemnamelist[0]['IdentifyingNumber']
+
+        LOG.debug(_('*****create_volume_from_snapshot,'
+                    'volumename:%(volumename)s,'
+                    'snapshotname:%(snapshotname)s,'
+                    'source volume instance:%(source_volume_instance)s,')
+                   % {'volumename': t_volumename,
+                      'snapshotname': snapshotname,
+                      'source_volume_instance': str(source_volume_instance.path)})
+
+        # get repservice for CreateElementReplica
+        repservice = self._find_eternus_service(REPL)
+
+        if repservice is None:
+            msg = (_('create_volume_from_snapshot,'
+                     'Replication Service not found'))
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # get poolname from driver configuration file
+        eternus_pool = self._get_drvcfg('EternusPool')
+        # Existence check the pool
+        pool = self._find_pool(eternus_pool)
+        if pool is None:
+            msg = (_('create_volume_from_snapshot,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'not found.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # set pooltype
+        if 'RSP' in pool['InstanceID']:
+            pooltype = RAIDGROUP
+        else:
+            pooltype = TPPOOL
+        # end of if
+
+        # Invoke method for create cloned volume from snapshot
+        rc, errordesc, job = self._exec_eternus_service(
+            'CreateElementReplica',
+            repservice,
+            TargetPool=pool,
+            SyncType=pywbem.Uint16(8),
+            SourceElement=source_volume_instance.path,
+            TargetElement=target_volume_instance.path)
+
+        if rc != 0L:
+            msg = (_('create_volume_from_snapshot,'
+                     'volumename:%(volumename)s,'
+                     'snapshotname:%(snapshotname)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s')
+                    % {'volumename': t_volumename,
+                       'snapshotname': snapshotname,
+                       'rc': rc,
+                       'errordesc':errordesc})
+            LOG.error(msg)
+            if rc == 5 and str(systemname[4]) == '2':
+                msg = (_('create_volume_from_snapshot,'
+                         'NOT supported on DX S2[%(backend)s].')
+                        % {'backend':systemname})
+                LOG.error(msg)
+            # end of if
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****create_volume_from_snapshot,Exit method'))
+
+        return {'FJ_Backend':systemname,
+                'FJ_Volume_Name':t_volumename,
+                'FJ_Pool_Name':eternus_pool,
+                'FJ_Pool_Type':POOL_TYPE_dic[pooltype]}
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_cloned_volume                                                                #
+    #         summary      : create cloned volume on ETERNUS                                       #
+    #         parameters   : volume, src_vref                                                      #
+    #         return-value : volume meta data                                                      #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def create_cloned_volume(self, volume, src_vref):
+        '''
+        Create clone of the specified volume.
+        '''
+        # sysnames              : FUJITSU_SrogareProduct
+        # backend               : ETERNUS model
+        # t_volumename          : target volumename on ETERNUS
+        # s_volumename          : source volumename on ETERNUS
+        # eternus_pool          : poolname
+        # pool                  : pool instance
+        # pooltype              : RAID(2) or TPP(5)
+        # repservice            : FUJITSU_ReplicationService
+        # source_volume_instance: source volume instance
+        # msg                   : message
+        # rc                    : result of invoke method
+        # errordesc             : error message
+        # job                   : unused
+
+        LOG.debug(_('*****create_cloned_volume,Enter method'))
+
+        # initialize
+        systemnamelist           = None
+        systemname               = None
+        t_volumename             = None
+        s_volumename             = None
+        eternus_pool             = None
+        pool                     = None
+        pooltype                 = 0
+        repservice               = None
+        source_volume_instance   = None
+        msg                      = None
+        rc                       = 0
+        errordesc                = None
+        job                      = None
+
+        # main processing
+        s_volumename           = self._create_volume_name(src_vref['id'])
+        self.conn              = self._get_eternus_connection()
+        source_volume_instance = self._find_lun(s_volumename)
+
+        # Existence check the source volume
+        if source_volume_instance is None:
+            msg=(_('create_cloned_volume,'
+                   'Source Volume is not exist in ETERNUS.'))
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        # create volume for destination of cloned volume
+        self.create_volume(volume)
+        t_volumename           = self._create_volume_name(volume['id'])
+        target_volume_instance = self._find_lun(t_volumename)
+
+        # get eternus model for metadata
+        # systemname = systemnamelist[0]['IdentifyingNumber']
+        # ex) ET092DC4511133A10
+        try:
+            systemnamelist = self.conn.EnumerateInstances(
+                'FUJITSU_StorageProduct')
+        except:
+            msg=(_('create_cloned_volume,'
+                   'volume:%(volume)s,'
+                   'EnumerateInstances,'
+                   'cannot connect to ETERNUS.')
+                  % {'volume':volume})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        systemname = systemnamelist[0]['IdentifyingNumber']
+
+        LOG.debug(_('*****create_cloned_volume,'
+                    'volumename:%(volumename)s,'
+                    'sourcevolumename:%(sourcevolumename)s,'
+                    'source volume instance:%(source_volume_instance)s,')
+                   % {'volumename': t_volumename,
+                      'sourcevolumename': s_volumename,
+                      'source_volume_instance': str(source_volume_instance.path)})
+
+        # get replicationservice for CreateElementReplica
+        repservice = self._find_eternus_service(REPL)
+
+        if repservice is None:
+            msg = (_('create_cloned_volume,'
+                     'Replication Service not found'))
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # get poolname from driver configuration file
+        eternus_pool = self._get_drvcfg('EternusPool')
+        # Existence check the pool
+        pool = self._find_pool(eternus_pool)
+        if pool is None:
+            msg = (_('create_cloned_volume,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'not found.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # set pooltype
+        if 'RSP' in pool['InstanceID']:
+            pooltype = RAIDGROUP
+        else:
+            pooltype = TPPOOL
+        # end of if
+
+        # Invoke method for create cloned volume from volume
+        rc, errordesc, job = self._exec_eternus_service(
+            'CreateElementReplica',
+            repservice,
+            TargetPool=pool,
+            SyncType=pywbem.Uint16(8),
+            SourceElement=source_volume_instance.path,
+            TargetElement=target_volume_instance.path)
+
+        if rc != 0L:
+            msg = (_('create_cloned_volume,'
+                     'volumename:%(volumename)s,'
+                     'sourcevolumename:%(sourcevolumename)s,'
+                     'source volume instance:%(source_volume_instance)s,'
+                     'target volume instance:%(target_volume_instance)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s')
+                    % {'volumename': t_volumename,
+                       'sourcevolumename': s_volumename,
+                       'source_volume_instance': str(source_volume_instance.path),
+                       'target_volume_instance': str(target_volume_instance.path),
+                       'rc': rc,
+                       'errordesc':errordesc})
+            LOG.error(msg)
+            if rc == 5 and str(systemname[4]) == '2':
+                msg = (_('create_cloned_volume,'
+                         'NOT supported on DX S2[%(backend)s].')
+                        % {'backend':systemname})
+                LOG.error(msg)
+            # end of if
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****create_cloned_volume,Exit method'))
+
+        return {'FJ_Backend':systemname,
+                'FJ_Volume_Name':t_volumename,
+                'FJ_Pool_Name':eternus_pool,
+                'FJ_Pool_Type':POOL_TYPE_dic[pooltype]}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : delete_volume                                                                       #
+    #         summary      : delete volume on ETERNUS                                              #
+    #         parameters   : volume                                                                #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def delete_volume(self, volume):
+        '''
+        Delete volume on ETERNUS.
+        '''
+        # volumename   : volumename on ETERNUS
+        # vol_instance : volume instance
+        # cps          : copy session instance
+        # configservice: FUJITSU_StorageConfigurationService
+        # msg          : message
+        # rc           : result of invoke method
+        # errordesc    : error message
+        # job          : unused
+
+        LOG.debug(_('*****delete_volume,Enter method'))
+
+        # initialize
+        volumename    = None
+        vol_instance  = None
+        cpsession     = None
+        configservice = None
+        msg           = None
+        rc            = 0
+        errordesc     = None
+        job           = None
+
+        # main preprocessing
+        volumename = self._create_volume_name(volume['id'])
+        self.conn  = self._get_eternus_connection()
+
+        # if volume is used by copysession,
+        # stop the copysession.
+        cpsession = self._find_copysession(volumename)
+        if cpsession is not None:
+            LOG.debug(_('*****delete_volume,volumename:%(volumename)s,'
+                        'volume is using by copysession[%(cpsession)s].delete copysession.')
+                       % {'volumename': volumename,
+                         'cpsession': cpsession})
+            self._delete_copysession(cpsession)
+        # end of if
+
+        # Existence check the volume
+        vol_instance = self._find_lun(volumename)
+        if vol_instance is None:
+            LOG.debug(_('*****delete_volume,volumename:%(volumename)s,'
+                        'volume not found on ETERNUS.'
+                        'delete only management data on cinder database.')
+                      % {'volumename': volumename})
+            return
+        # end of if
+
+        # begin volume deletion processing
+        configservice = self._find_eternus_service(STOR_CONF)
+        if configservice is None:
+            msg = (_('delete_volume,volumename:%(volumename)s,'
+                     'Storage Configuration Service not found.')
+                    % {'volumename': volumename})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****delete_volume,volumename:%(volumename)s,'
+                    'vol_instance:%(vol_instance)s,'
+                    'Method: ReturnToStoragePool')
+                   % {'volumename': volumename,
+                      'vol_instance': str(vol_instance.path)})
+
+        # Invoke method for delete volume
+        rc, errordesc, job = self._exec_eternus_service(
+            'ReturnToStoragePool',
+            configservice,
+            TheElement=vol_instance.path)
+
+        if rc != 0L:
+            msg = (_('delete_volume,volumename:%(volumename)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s')
+                    % {'volumename': volumename,
+                       'rc': rc,
+                       'errordesc': errordesc})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****delete_volume,volumename:%(volumename)s,'
+                    'Return code:%(rc)lu,'
+                    'Error:%(errordesc)s,'
+                    'Exit Method')
+                  % {'volumename': volumename,
+                     'rc': rc,
+                     'errordesc': errordesc})
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_snapshot                                                                     #
+    #         summary      : create snapshot using SnapOPC                                         #
+    #         parameters   : snapshot                                                              #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def create_snapshot(self, snapshot):
+        '''
+        create snapshot using SnapOPC
+        '''
+        # snapshotname  : snapshot name on Openstack
+        # volumename    : source volume name on Openstack
+        # vol_id        : source volume id
+        # volume        : source volume dictionary
+        # vol_instance  : source volume instance
+        # s_volumename  : source volume name on ETERNUS
+        # d_volumename  : destination volume name on ETERNUS
+        # eternus_pool  : poolname
+        # pool          : pool instance
+        # configservice : FUJITSU_StorageConfigurationService
+        # msg           : message
+        # rc            : result of invoke method
+        # errordesc     : error message
+        # job           : unused
+
+        LOG.debug(_('*****create_snapshot,Enter method'))
+
+        # initialize
+        snapshotname  = None
+        volumename    = None
+        vol_id        = None
+        volume        = None
+        vol_instance  = None
+        d_volumename  = None
+        s_volumename  = None
+        vol_instance  = None
+        configservice = None
+        eternus_pool  = None
+        pool          = None
+        msg           = None
+        rc            = 0
+        errordesc     = None
+        job           = None
+
+        # main processing
+        snapshotname  = snapshot['name']
+        volumename    = snapshot['volume_name']
+        vol_id        = snapshot['volume_id']
+        volume        = snapshot['volume']
+        d_volumename  = self._create_volume_name(snapshot['id'])
+        s_volumename  = self._create_volume_name(vol_id)
+        vol_instance  = self._find_lun(s_volumename)
+        configservice = self._find_eternus_service(STOR_CONF)
+        self.conn     = self._get_eternus_connection()
+
+        # Existence check the volume
+        if vol_instance is None:
+            # source volume is not found on ETERNUS
+            msg = (_('create_snapshot,'
+                     'volumename on ETERNUS:%(s_volumename)s,'
+                     'source volume is not found on ETERNUS.')
+                    % {'s_volumename': s_volumename})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        if configservice is None:
+            msg = (_('create_snapshot,'
+                     'volumename:%(volumename)s,'
+                     'Storage Configuration Service not found.')
+                    % {'volumename': volumename})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # get poolname from driver configuration file
+        eternus_pool  = self._get_drvcfg('EternusPool')
+        # Existence check the pool
+        pool          = self._find_pool(eternus_pool)
+        if pool is None:
+            msg = (_('create_snapshot,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'not found.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****create_snapshot,'
+                    'snapshotname:%(snapshotname)s,'
+                    'source volume name:%(volumename)s,'
+                    'vol_instance.path:%(vol_instance)s,'
+                    'dest_volumename:%(d_volumename)s,'
+                    'pool:%(pool)s,'
+                    'Invoke CreateReplica')
+                   % {'snapshotname': snapshotname,
+                      'volumename': volumename,
+                      'vol_instance': str(vol_instance.path),
+                      'd_volumename': d_volumename,
+                      'pool': pool})
+
+        # Invoke method for create snapshot
+        rc, errordesc, job = self._exec_eternus_service(
+            'CreateReplica',
+            configservice,
+            ElementName=d_volumename,
+            TargetPool=pool,
+            CopyType=pywbem.Uint16(4),
+            SourceElement=vol_instance.path)
+
+        if rc != 0L:
+            msg = (_('create_snapshot,'
+                     'snapshotname:%(snapshotname)s,'
+                     'source volume name:%(volumename)s,'
+                     'vol_instance.path:%(vol_instance)s,'
+                     'dest_volumename:%(d_volumename)s,'
+                     'pool:%(pool)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s')
+                    % {'snapshotname': snapshotname,
+                       'volumename': volumename,
+                       'vol_instance': str(vol_instance.path),
+                       'd_volumename': d_volumename,
+                       'pool': pool,
+                       'rc': rc,
+                       'errordesc':errordesc})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****create_snapshot,volumename:%(volumename)s,'
+                    'Return code:%(rc)lu,'
+                    'Error:%(errordesc)s,'
+                    'Exit Method')
+                  % {'volumename': volumename,
+                     'rc': rc,
+                     'errordesc': errordesc})
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : delete_snapshot                                                                     #
+    #         summary      : delete snapshot                                                       #
+    #         parameters   : snapshot                                                              #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def delete_snapshot(self, snapshot):
+        '''
+        delete snapshot
+        '''
+        # Delete snapshot - deletes the target element and the snap session
+        # snapshotname  : snapshot display name
+        # volumename    : source volume display name on openstack
+        # d_volumename  : destination volume name on ETERNUS
+        # snapshot['id']: destination volume id for _find_lun
+        # cpsession     : Storage Synchronized
+        # repservice    : FUJITSU_ReplicationService
+        # msg           : message
+        # rc            : result of invoke method
+        # errordesc     : error message
+
+        LOG.debug(_('*****delete_snapshot,Enter method'))
+
+        # initialize
+
+        # main processing
+
+        self.delete_volume(snapshot)
+
+        LOG.debug(_('*****delete_snapshot,Exit method'))
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : initialize_connection                                                               #
+    #         summary      : set HostAffinityGroup on ETERNUS                                      #
+    #         parameters   : volume, connector                                                     #
+    #         return-value : connection info                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def initialize_connection(self, volume, connector):
+        '''
+        Allow connection to connector and return connection info.
+        '''
+        # targetlist : target port id list
+        # mapdata    : the element which constitutes device_info
+        # msg        : message
+        # device_info: return value
+
+        LOG.debug(_('*****initialize_connection,Enter method'))
+
+        # initialize
+        targetlist  = []
+        mapdata     = {}
+        msg         = None
+        device_info = {}
+
+        # main processing
+        self.conn  = self._get_eternus_connection()
+        targetlist = self._get_target_portid(connector)
+        mapdata    = self._find_device_number(volume, connector, targetlist)
+
+        if len(mapdata) == 0:
+            # volume not found on ETERNUS
+            msg = (_('initialize_connection,'
+                     'volume:%(volume)s,'
+                     'Volume not found.')
+                    % {'volume':volume['name']})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        if mapdata['target_lun'] is not None:
+            # volume is already mapped
+            msg = (_('initialize_connection,'
+                     'volume:%(volume)s,'
+                     'target_lun:%(target_lun)s,'
+                     'Volume is already mapped.')
+                    % {'volume':volume['name'],
+                       'target_lun':mapdata['target_lun']})
+            LOG.info(msg)
+        else:
+            self._map_lun(volume, connector, targetlist)
+            mapdata = self._find_device_number(volume, connector, targetlist)
+        # end of if
+
+        mapdata['target_discoverd'] = True
+        mapdata['volume_id']        = volume['id']
+
+        if self.protocol == 'iSCSI':
+            device_info = {'driver_volume_type': 'iscsi',
+                           'data': mapdata}
+        elif self.protocol == 'fc':
+            device_info = {'driver_volume_type': 'fibre_channel',
+                           'data': mapdata}
+        # end of if
+
+        LOG.debug(_('*****initialize_connection,'
+                    'device_info:%(info)s,'
+                    'Exit method')
+                  % {'info': device_info})
+
+        return device_info
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : terminate_connection                                                                #
+    #         summary      : remove HostAffinityGroup on ETERNUS                                   #
+    #         parameters   : volume, connector                                                     #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def terminate_connection(self, volume, connector, force=False, **kwargs):
+        '''
+        Disallow connection from connector
+        '''
+        LOG.debug(_('*****terminate_connection,Enter method'))
+
+        # main processing
+        self.conn = self._get_eternus_connection()
+        self._unmap_lun(volume, connector)
+
+        LOG.debug(_('*****terminate_connection,Exit method'))
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : extend_volume                                                                       #
+    #         summary      : extend volume on ETERNUS                                              #
+    #         parameters   : volume new_size                                                       #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def extend_volume(self, volume, new_size):
+        '''
+        extend volume on ETERNUS
+        '''
+        # volumesize              : volume new size Byte
+        # volumename              : volumename on ETERNUS
+        # source_volume_instance  : source volume instance
+        # eternus_pool            : poolname
+        # pool                    : pool instance
+        # pooltype                : RAID(2) or TPP(5)
+        # configservice           : FUJITSU_StorageConfigurationService
+        # msg                     : message
+        # rc                      : result of invoke method
+        # errordesc               : error message
+        # job                     : unused
+
+        LOG.debug(_('*****extend_volume,Enter method'))
+
+        # initialize
+        systemnamelist         = None
+        volumesize             = 0
+        volumename             = None
+        source_volume_instance = None
+        eternus_pool           = None
+        pool                   = None
+        pooltype               = 0
+        configservice          = None
+        msg                    = None
+        rc                     = 0
+        errordesc              = None
+        job                    = None
+
+        #main processing
+        #conversion of the unit. GB to B
+        volumesize = new_size * 1073741824
+        #create to volumename on ETERNUS from cinder VolumeID
+        volumename = self._create_volume_name(volume['id'])
+        #get source volume instance
+        source_volume_instance = self._find_lun(volumename)
+        if source_volume_instance is None:
+            msg = (_('extend_volume,'
+                     'source_volume:%(volumename)s,'
+                     'not found.')
+                    % {'volumename': volumename})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****extend_volume,volumename:%(volumename)s,'
+                    'volumesize:%(volumesize)u,'
+                    'source volume instance:%(source_volume_instance)s,'
+                  % {'volumename': volumename,
+                     'volumesize': volumesize,
+                     'source_volume_instance': str(source_volume_instance.path)}))
+
+        self.conn = self._get_eternus_connection()
+
+        # get poolname from driver configuration file
+        eternus_pool = self._get_drvcfg('EternusPool')
+        # Existence check the pool
+        pool = self._find_pool(eternus_pool)
+        if pool is None:
+            msg = (_('extend_volume,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'not found.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # set pooltype
+        if 'RSP' in pool['InstanceID']:
+            pooltype = RAIDGROUP
+        else:
+            pooltype = TPPOOL
+        # end of if
+
+        configservice = self._find_eternus_service(STOR_CONF)
+        if configservice is None:
+            msg = (_('extend_volume,volume:%(volume)s,'
+                     'volumename:%(volumename)s,'
+                     'eternus_pool:%(eternus_pool),'
+                     'Error!! Storage Configuration Service is None.')
+                    % {'volume':volume,
+                       'volumename': volumename,
+                       'eternus_pool':eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+        LOG.debug(_('*****extend_volume,CreateOrModifyElementFromStoragePool,'
+                    'ConfigService:%(service)s,'
+                    'ElementName:%(volumename)s,'
+                    'InPool:%(eternus_pool)s,'
+                    'ElementType:%(pooltype)u,'
+                    'Size:%(volumesize)u,'
+                    'TheElement:%(source_volume_instance)s')
+                   % {'service':configservice,
+                      'volumename': volumename,
+                      'eternus_pool':eternus_pool,
+                      'pooltype':pooltype,
+                      'volumesize': volumesize,
+                      'source_volume_instance': str(source_volume_instance.path)})
+
+        # Invoke method for extend volume
+        rc, errordesc, job = self._exec_eternus_service(
+            'CreateOrModifyElementFromStoragePool',
+            configservice,
+            ElementName=volumename,
+            InPool=pool,
+            ElementType=pywbem.Uint16(pooltype),
+            Size=pywbem.Uint64(volumesize),
+            TheElement=source_volume_instance.path)
+
+        if rc != 0L:
+            msg = (_('extend_volume,'
+                     'volumename:%(volumename)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s,'
+                     'PoolType:%(pooltype)s')
+                    % {'volumename': volumename,
+                       'rc': rc,
+                       'errordesc':errordesc,
+                       'pooltype':POOL_TYPE_dic[pooltype]})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****extend_volume,'
+                    'volumename:%(volumename)s,'
+                    'Return code:%(rc)lu,'
+                    'Error:%(errordesc)s,'
+                    'Pool Name:%(eternus_pool)s,'
+                    'Pool Type:%(pooltype)s,'
+                    'Leaving extend_volume')
+                   % {'volumename': volumename,
+                      'rc': rc,
+                      'errordesc':errordesc,
+                      'eternus_pool':eternus_pool,
+                      'pooltype':POOL_TYPE_dic[pooltype]})
+        return
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : refresh_volume_stats                                                                #
+    #         summary      : get pool capacity                                                     #
+    #         parameters   : None                                                                  #
+    #         return-value : self.stats                                                            #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def refresh_volume_stats(self):
+        '''
+        get pool capacity.
+        '''
+        # eternus_pool : poolname
+        # pool         : pool instance
+
+        LOG.debug(_('*****refresh_volume_stats,Enter method'))
+
+        # initialize
+        eternus_pool = None
+        pool         = None
+
+        # main processing
+        self.conn    = self._get_eternus_connection()
+        eternus_pool = self._get_drvcfg('EternusPool')
+        pool         = self._find_pool(eternus_pool,True)
+
+        # Existence check the pool
+        if pool is None:
+            msg = (_('refresh_volume_stats,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'not found.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.info(msg)
+
+            # create pool(RAID Group)
+            self._create_pool(eternus_pool)
+            pool = self._find_pool(eternus_pool,True)
+            if pool is None:
+                msg = (_('refresh_volume_stats,'
+                         'eternus_pool:%(eternus_pool)s,'
+                         'not found after create_pool.')
+                        % {'eternus_pool': eternus_pool})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+            # end of if
+        # end of if
+
+        self.stats['total_capacity_gb'] = pool['TotalManagedSpace']
+        self.stats['free_capacity_gb']  = pool['RemainingManagedSpace']
+
+        LOG.debug(_('*****refresh_volume_stats,'
+                    'eternus_pool:%(eternus_pool)s,'
+                    'total capacity[%(total)s],'
+                    'free capacity[%(free)s]')
+                   % {'eternus_pool':eternus_pool,
+                      'total':self.stats['total_capacity_gb'],
+                      'free':self.stats['free_capacity_gb']})
+
+        return self.stats
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_device_number                                                                 #
+    #         summary      : return number of mapping order                                        #
+    #         parameters   : volume, connector, targetlist                                         #
+    #         return-value : mapping order                                                         #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_device_number(self, volume, connector, targetlist = []):
+        '''
+        return mapping order
+        '''
+        # map_num          : number of mapping order
+        # mapdata          : device information
+        # volumename       : volumename on ETERNUS
+        # vol_instance     : volume instance
+        # ag_instance      : affinity group instance
+        # aglist           : affinity group list associated with the connector and the volume
+        # targetlist       : target portid
+        # vo_volmaplist    : volume mapping information list associated with the volume
+        # ag_volmaplist    : volume mapping information list associated with the affinitygroup
+        # vo_volmap        : volume mapping information associated with the volume
+        # ag_volmap        : volume mapping information associated with the affinitygroup
+        # volmapinstance   : volume mapping instance
+        # iqn              : iSCSI Qualified Name associated with the volume and the affinitygroup
+        # found_volmaplist : volume mapping information list
+
+        LOG.debug(_('*****_find_device_number,Enter method'))
+
+        # initialize
+        map_num          = None
+        mapdata          = {}
+        volumename       = None
+        vol_instance     = None
+        ag_instance      = None
+        aglist           = []
+        vo_volmaplist    = []
+        ag_volmaplist    = []
+        vo_volmap        = None
+        ag_volmap        = None
+        volmapinstance   = {}
+        iqn              = None
+        found_volmaplist = []
+
+        # main processing
+        volumename   = self._create_volume_name(volume['id'])
+        vol_instance = self._find_lun(volumename)
+
+        # Existence check the volume
+        if vol_instance is None:
+            # volume does not found
+            LOG.debug(_('*****_find_device_number,Device does not found.'))
+            return mapdata
+        # end of if
+
+        # find affinity group
+        # attach the connector and include the volume
+        aglist = self._find_affinity_group(connector, vol_instance)
+        if len(aglist) == 0 :
+            LOG.debug(_('*****_find_device_number,ag_list:%s') % (aglist))
+        else:
+            ag_instance = self.conn.GetInstance(aglist[0],LocalOnly=False)
+
+            # get volume mapping order
+            try:
+                ag_volmaplist = self.conn.ReferenceNames(
+                          ag_instance.path,
+                          ResultClass='CIM_ProtocolControllerForUnit')
+                vo_volmaplist = self.conn.ReferenceNames(
+                          vol_instance.path,
+                          ResultClass='CIM_ProtocolControllerForUnit')
+            except:
+                msg=(_('_find_device_number,'
+                   'volume:%(volume)s,'
+                   'ReferenceNames,'
+                   'cannot connect to ETERNUS.')
+                  % {'volume':volume})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            LOG.debug(_('*****_find_device_number,'
+                    'ag_volmaplist:%(ag_volmaplist)s,'
+                    'vo_volmaplist:%(vo_volmaplist)s'
+                    )
+                   % {'ag_volmaplist':ag_volmaplist,
+                      'vo_volmaplist':vo_volmaplist})
+
+            for ag_volmap in ag_volmaplist:
+                for vo_volmap in vo_volmaplist:
+                    LOG.debug(_('*****_find_device_number,ag_volmap:%s') % (ag_volmap))
+                    LOG.debug(_('*****_find_device_number,vo_volmap:%s') % (vo_volmap))
+                    if ag_volmap == vo_volmap:
+                        found_volmaplist.append(ag_volmap)
+                        break
+                    # end of if
+                if len(found_volmaplist) != 0:
+                    break
+                # end of if
+            # end of for ag_volmaplist
+            LOG.debug(_('*****_find_device_number,found_volmaplist:%s') % found_volmaplist)
+
+            for found_volmap in found_volmaplist:
+                try:
+                    volmapinstance = self.conn.GetInstance(
+                    found_volmap,
+                    LocalOnly=False)
+                except:
+                    msg=(_('_find_device_number,'
+                           'volume:%(volume)s,'
+                           'GetInstance,'
+                           'cannot connect to ETERNUS.')
+                          % {'volume':volume})
+                    LOG.error(msg)
+                    raise exception.VolumeBackendAPIException(data=msg)
+
+                map_num = int(volmapinstance['DeviceNumber'], 16)
+                LOG.debug(_('*****_find_device_number,found_volmap:%s') % (found_volmap))
+                LOG.debug(_('*****_find_device_number,map_num:%s') % (map_num))
+            # end of for found_volmaplist
+        # end of if
+
+        if map_num is None:
+            msg = (_('_find_device_number,'
+                     'Device number not found for volume'
+                     '%(volumename)s %(vol_instance)s.')
+                    % {'volumename': volumename,
+                       'vol_instance': str(vol_instance.path)})
+            LOG.info(msg)
+        else:
+            LOG.debug(_('*****_find_device_number,'
+                        'Found device number %(device)d for volume'
+                        ' %(volumename)s %(vol_instance)s.')
+                       % {'device': map_num,
+                          'volumename': volumename,
+                          'vol_instance': str(vol_instance.path)})
+        # end of if
+
+
+        if self.protocol == 'iSCSI':
+            iqn = self._get_iqn()
+
+            LOG.debug(_('*****_find_device_number,'
+                        'iqn:%(iqn)s')
+                       % {'iqn':iqn})
+            target_portal = '%s:%s' % (self.configuration.iscsi_ip_address,
+                                       self.configuration.iscsi_port)
+            mapdata = {'target_lun': map_num,
+                       'target_iqn': iqn,
+                       'target_portal': target_portal}
+
+        elif self.protocol == 'fc':
+            if len(targetlist) == 0:
+                targetlist = self._get_target_portid(connector)
+            # end of if
+
+            LOG.debug(_('*****_find_device_number,'
+                        'targetlist:%(targetlist)s')
+                       % {'targetlist':targetlist})
+
+            mapdata = {'target_lun': map_num,
+                    'target_wwn': targetlist}
+        # end of if
+
+        LOG.debug(_('*****_find_device_number,Device info: %(mapdata)s.')
+                   % {'mapdata': mapdata})
+
+        return mapdata
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _get_drvcfg                                                                         #
+    #         summary      : read parameter from driver configuration file                         #
+    #         parameters   : tagname, filename                                                     #
+    #         return-value : value of tagname                                                      #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _get_drvcfg(self,tagname,filename=None):
+        '''
+        read from driver configuration file.
+        '''
+        # filename  : driver configuration file name
+        # tagname   : xml tagname
+        # tree      : element tree from driver configuration file
+        # elem      : root element
+        # ret       : return value
+
+        LOG.debug(_('*****_get_drvcfg,Enter method'))
+
+        # initialize
+        tree = None
+        elem = None
+        ret  = None
+
+        # main processing
+        if filename is None:
+            # set default configuration file name
+            filename = self.configuration.cinder_eternus_config_file
+        # end of if
+
+        LOG.debug(_("*****_get_drvcfg input[%s][%s]") %(filename, tagname))
+
+        tree = parse(filename)
+        elem = tree.getroot()
+        ret  = elem.findtext(".//"+tagname)
+
+        if ret is None or ret == "":
+            msg = (_('_get_drvcfg,'
+                     'filename:%(filename)s,'
+                     'tagname:%(tagname)s,'
+                     'data is None!!  '
+                     'Please edit driver configuration file and correct an error. ')
+                    % {'filename':filename,
+                       'tagname':tagname})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_("*****_get_drvcfg output[%s]") %(ret))
+
+        return ret
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _get_eternus_connection                                                             #
+    #         summary      : return WBEM connection                                                #
+    #         parameters   : filename                                                              #
+    #         return-value : WBEM connection                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _get_eternus_connection(self, filename=None):
+        '''
+        return WBEM connection
+        '''
+        # filename  : driver configuration file name
+        # ip        : SMI-S IP address
+        # port      : SMI-S port
+        # user      : SMI-S username
+        # password  : SMI-S password
+        # url       : SMI-S connection url
+        # conn      : WBEM connection
+
+        LOG.debug(_("*****_get_eternus_connection [%s],"
+                    "Enter method")
+                   % filename)
+
+        # initialize
+        ip       = None
+        port     = None
+        user     = None
+        password = None
+        url      = None
+        conn     = None
+
+        # main processing
+        ip     = self._get_drvcfg('EternusIP', filename)
+        port   = self._get_drvcfg('EternusPort', filename)
+        user   = self._get_drvcfg('EternusUser', filename)
+        passwd = self._get_drvcfg('EternusPassword', filename)
+        url    = 'http://'+ip+':'+port
+
+        conn   = pywbem.WBEMConnection(url, (user, passwd),
+                                     default_namespace='root/eternus')
+
+        if conn is None:
+            msg = (_('_get_eternus_connection,'
+                     'filename:%(filename)s,'
+                     'ip:%(ip)s,'
+                     'port:%(port)s,'
+                     'user:%(user)s,'
+                     'passwd:%(passwd)s,'
+                     'url:%(url)s,'
+                     'FAILED!!.')
+                    % {'filename':filename,
+                       'ip':ip,
+                       'port':port,
+                       'user':user,
+                       'passwd':passwd,
+                       'url':url})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****_get_eternus_connection,[%s],Exit method') % (conn))
+
+        return conn
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _create_volume_name                                                                 #
+    #         summary      : create volume_name on ETERNUS from id on OpenStack.                   #
+    #         parameters   : id_code                                                               #
+    #         return-value : volumename on ETERNUS                                                 #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _create_volume_name(self, id_code):
+        '''
+        create volume_name on ETERNUS from id on OpenStack.
+        '''
+        # id_code         : volume_id, snapshot_id etc..
+        # m               : hashlib.md5 instance
+        # ret             : volumename on ETERNUS
+        # systemnamelist  : ETERNUS information list
+        # systemname      : ETERNUS model information
+
+        LOG.debug(_('*****_create_volume_name [%s],Enter method.')
+                   % id_code)
+
+        # initialize
+        m               = None
+        ret             = None
+        systemnamelist  = None
+        systemname      = None
+
+        # main processing
+        if id_code is None:
+            msg=(_('_create_volume_name,'
+                   'id_code is None.'))
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        m = hashlib.md5()
+        m.update(id_code)
+        ret = VOL_PREFIX + str(base64.urlsafe_b64encode(m.digest()))
+
+        # get eternus model for volumename length
+        # systemname = systemnamelist[0]['IdentifyingNumber']
+        # ex) ET092DC4511133A10
+        try:
+            systemnamelist = self.conn.EnumerateInstances(
+                'FUJITSU_StorageProduct')
+        except:
+            msg=(_('create_volume_name,'
+                   'id_code:%(id_code)s,'
+                   'EnumerateInstances,'
+                   'cannot connect to ETERNUS.')
+                  % {'id_code':id_code})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        systemname = systemnamelist[0]['IdentifyingNumber']
+
+        LOG.debug(_('*****_create_volume_name,'
+                    'systemname:%(systemname)s,'
+                    'storage is DX S%(model)s')
+                   % {'systemname':systemname,
+                      'model':systemname[4]})
+
+        # shorten volumename when storage is DX S2 series
+        if str(systemname[4]) == '2':
+            LOG.debug(_('*****_create_volume_name,'
+                        'volumename is 16 digit.'))
+            ret = ret[:16]
+        # end of if
+
+        LOG.debug(_('*****_create_volume_name,'
+                    'ret:%(ret)s,'
+                    'Exit method.')
+                   % {'ret':ret})
+
+        return ret
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _get_pool_instance_id                                                               #
+    #         summary      : get pool instacne_id from pool name on ETERNUS                        #
+    #         parameters   : eternus_pool                                                          #
+    #         return-value : pool instance id                                                      #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _get_pool_instance_id(self, eternus_pool):
+        '''
+        get pool instacne_id from pool name on ETERNUS
+        '''
+        # eternus_pool  : pool name on ETERNUS.
+        # poolinstanceid: ETERNUS pool instance id(return value)
+        # tppoollist    : list of thinprovisioning pool on ETERNUS.
+        # rgpoollist    : list of raid group on ETERNUS.
+        # tppool        : Thinprovisioning Pool
+        # rgpool        : RAID Group
+        # msg           : message
+
+        LOG.debug(_('*****_get_pool_instance_id,'
+                    'Enter method'))
+
+        # initialize
+        poolinstanceid = None
+        tppoollist    = []
+        rgpoollist    = []
+        tppool        = None
+        rgpool        = None
+        poolname      = None
+        msg           = None
+
+
+        # main processing
+        try:
+            rgpoollist = self.conn.EnumerateInstances(
+                'FUJITSU_RAIDStoragePool')
+            tppoollist = self.conn.EnumerateInstances(
+                'FUJITSU_ThinProvisioningPool')
+        except:
+            msg=(_('_get_pool_instance_id,'
+                   'eternus_pool:%(eternus_pool)s,'
+                   'EnumerateInstances,'
+                   'cannot connect to ETERNUS.')
+                  % {'eternus_pool':eternus_pool})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+
+        for rgpool in rgpoollist:
+            poolname = rgpool['ElementName']
+            if str(eternus_pool) == str(poolname):
+                poolinstanceid = rgpool['InstanceID']
+                break
+            # end of if
+        else:
+            for tppool in tppoollist:
+                poolname = tppool['ElementName']
+                if str(eternus_pool) == str(poolname):
+                    poolinstanceid = tppool['InstanceID']
+                    break
+                # end of if
+            # end of for tppoollist
+        # end of for rgpoollist
+
+        if poolinstanceid is None:
+            msg = (_('_get_pool_instance_id,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'poolinstanceid is None.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.info(msg)
+        # end of if
+
+        LOG.debug(_('*****_get_pool_instance_id,'
+                    'Exit method'))
+
+        return poolinstanceid
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _create_pool                                                                        #
+    #         summary      : create raidgroup on ETERNUS                                           #
+    #         parameters   : eternus_pool                                                          #
+    #         return-value : None                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _create_pool(self, eternus_pool):
+        '''
+          create raidgroup on ETERNUS.
+        '''
+        #  create raidgroup on ETERNUS.
+        #  raidgroup name is eternus_pool.
+        #  raidlevel and diskdrives are automatically selected.
+        #
+        # eternus_pool : poolname on ETERNUS
+        # configservice: FUJITSU_StorageConfigurationService
+        # msg          : message
+        # rc           : result of invoke method
+        # errordesc    : error message
+        # job          : unused
+
+        LOG.debug(_('*****_create_pool,'
+                    'eternus_pool:%(eternus_pool)s,'
+                    'Enter method.')
+                   % {'eternus_pool': eternus_pool})
+
+        # initialize
+        poolinstance  = None
+        configservice = None
+        msg           = None
+        rc            = 0
+        errordesc     = None
+        job           = None
+
+        # main processing
+        configservice = self._find_eternus_service(STOR_CONF)
+        if configservice is None:
+            msg = (_('_create_pool,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'configservice is None.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # Invoke method for create pool
+        # Raid Level and DiskDrives are automatically selected.
+        rc, errordesc, job = self._exec_eternus_service(
+            'CreateOrModifyStoragePool',
+            configservice,
+            ElementName=eternus_pool)
+
+        if rc != 0L:
+            msg=(_('_create_pool,'
+                   'eternus_pool:%(eternus_pool)s,'
+                   'Return code:%(rc)lu,'
+                   'Error:%(errordesc)s')
+                  % {'eternus_pool':eternus_pool,
+                     'rc':rc,
+                     'errordesc':errordesc})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****_create_pool,'
+                    'eternus_pool:%(eternus_pool)s,'
+                    'Exit method.')
+                   % {'eternus_pool': eternus_pool})
+
+        return
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_pool                                                                          #
+    #         summary      : find Instance or Name of pool by pool name on ETERNUS.                #
+    #         parameters   : eternus_pool, detail                                                  #
+    #         return-value : pool instance or instance name                                        #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_pool(self, eternus_pool, detail=False):
+        '''
+        find Instance or InstanceName of pool by pool name on ETERNUS.
+        '''
+        # eternus_pool  : poolname
+        # detail        : False >return EnumerateInstanceNames
+        #               : True  >return EnumerateInstances
+        # poolinstanceid: pool instance id
+        # poolinstance  : pool instance
+        # msg           : message
+        # tppoollist    : list of thinprovisioning pool on ETERNUS.
+        # rgpoollist    : list of raid group on ETERNUS.
+
+        LOG.debug(_('*****_find_pool,Enter method'))
+
+        # initialize
+        poolinstanceid = None
+        poolinstance   = None
+        msg            = None
+        tppoollist     = []
+        rgpoollist     = []
+
+        #main processing
+        poolinstanceid = self._get_pool_instance_id(eternus_pool)
+        #if pool instance is None then create pool on ETERNUS.
+        if poolinstanceid is None:
+            msg = (_('_find_pool,'
+                     'eternus_pool:%(eternus_pool)s,'
+                     'poolinstanceid is None.')
+                    % {'eternus_pool': eternus_pool})
+            LOG.info(msg)
+
+        else:
+
+            if detail is True:
+                try:
+                    tppoollist = self.conn.EnumerateInstances(
+                        'FUJITSU_ThinProvisioningPool')
+                    rgpoollist = self.conn.EnumerateInstances(
+                        'FUJITSU_RAIDStoragePool')
+                except:
+                    msg=(_('_find_pool,'
+                           'eternus_pool:%(eternus_pool)s,'
+                           'EnumerateInstances,'
+                           'cannot connect to ETERNUS.')
+                          % {'eternus_pool':eternus_pool})
+                    LOG.error(msg)
+                    raise exception.VolumeBackendAPIException(data=msg)
+
+            else:
+                try:
+                    tppoollist = self.conn.EnumerateInstanceNames(
+                        'FUJITSU_ThinProvisioningPool')
+                    rgpoollist = self.conn.EnumerateInstanceNames(
+                        'FUJITSU_RAIDStoragePool')
+                except:
+                    msg=(_('_find_pool,'
+                           'eternus_pool:%(eternus_pool)s,'
+                           'EnumerateInstanceNames,'
+                           'cannot connect to ETERNUS.')
+                          % {'eternus_pool':eternus_pool})
+                    LOG.error(msg)
+                    raise exception.VolumeBackendAPIException(data=msg)
+            # end of if
+
+            for tppool in tppoollist:
+                if str(poolinstanceid) == str(tppool['InstanceID']):
+                    poolinstance = tppool
+                    break
+                # end of if
+            else:
+                for rgpool in rgpoollist:
+                    if str(poolinstanceid) == str(rgpool['InstanceID']):
+                        poolinstance = rgpool
+                        break
+                    # end of if
+                # end of for rgpoollist
+            # end of for tppoollist
+        # end of if
+        LOG.debug(_('*****_find_pool,'
+                    'poolinstance: %(poolinstance)s,'
+                    'Exit method.')
+                   % {'poolinstance': str(poolinstance)})
+
+        return poolinstance
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_eternus_service                                                               #
+    #         summary      : find CIM instance                                                     #
+    #         parameters   : classname                                                             #
+    #         return-value : CIM instance                                                          #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_eternus_service(self, classname):
+        '''
+        find CIM instance
+        '''
+        # ret      : CIM instance
+        # services : CIM instance service name
+
+        LOG.debug(_('*****_find_eternus_service,'
+                    'classname:%(a)s,'
+                    'Enter method')
+                   % {'a':str(classname)})
+
+        # initialize
+        ret      = None
+        services = None
+
+        # main processing
+        try:
+            services = self.conn.EnumerateInstanceNames(
+                str(classname))
+        except:
+            msg=(_('_find_eternus_service,'
+                   'classname:%(classname)s,'
+                   'EnumerateInstanceNames,'
+                   'cannot connect to ETERNUS.')
+                  % {'classname':str(classname)})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        ret = services[0]
+        LOG.debug(_('*****_find_eternus_service,'
+                    'classname:%(classname)s,'
+                    'ret:%(ret)s,'
+                    'Exit method')
+                   % {'classname':classname,
+                      'ret':(str(ret))})
+        return ret
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _exec_eternus_service                                                               #
+    #         summary      : Execute SMI-S Method                                                  #
+    #         parameters   : classname, instanceNameList, param_dict                               #
+    #         return-value : status code, error description, data                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _exec_eternus_service(self, classname, instanceNameList, **param_dict):
+        '''
+        Execute SMI-S Method
+        '''
+        # rc       : result of InvokeMethod
+        # retdata  : return data
+        # errordesc: error description
+
+        LOG.debug(_('*****_exec_eternus_service,'
+                    'classname:%(a)s,'
+                    'instanceNameList:%(b)s,'
+                    'paramters:%(c)s,'
+                    'Enter method')
+                   % {'a':str(classname),
+                      'b':str(instanceNameList),
+                      'c':str(param_dict)})
+
+        # initialize
+        rc        = None
+        retdata   = None
+        errordesc = None
+
+        # main processing
+        # use InvokeMethod
+        try:
+            rc, retdata = self.conn.InvokeMethod(
+                classname,
+                instanceNameList,
+                **param_dict)
+        except:
+            if rc is None:
+                msg=(_('_exec_eternus_service,'
+                       'classname:%(classname)s,'
+                       'InvokeMethod,'
+                       'cannot connect to ETERNUS.')
+                      % {'classname':str(classname)})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+            # end of if
+        # convert errorcode to error description
+        try:
+            errordesc = RETCODE_dic[str(rc)]
+        except:
+            errordesc = 'Undefined Error!!'
+        ret = (rc, errordesc, retdata)
+
+        LOG.debug(_('*****_exec_eternus_service,'
+                    'classname:%(a)s,'
+                    'instanceNameList:%(b)s,'
+                    'paramters:%(c)s,'
+                    'Return code:%(rc)s,'
+                    'Error:%(errordesc)s,'
+                    'Exit method')
+                   % {'a':str(classname),
+                      'b':str(instanceNameList),
+                      'c':str(param_dict),
+                      'rc':str(rc),
+                      'errordesc':errordesc})
+
+        return ret
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_lun                                                                           #
+    #         summary      : find lun instance from volume class or volumename on ETERNUS.         #
+    #         parameters   : volume                                                                #
+    #         return-value : volume instance                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_lun(self, volumename):
+        '''
+        find lun instance from volume class or volumename on ETERNUS.
+        '''
+        # volumename    : volume name on ETERNUS
+        # namelist      : volume list
+        # name          : volume instanceName
+        # vol_instance  : volume instance for temp
+        # volumeinstance: volume instance for return
+
+        LOG.debug(_('*****_find_lun,Enter method'))
+
+        # initialize
+        namelist       = []
+        name           = None
+        vol_instance   = None
+        volumeinstance = None
+
+        # main processing
+        LOG.debug(_('*****_find_lun,'
+                    'volumename:%(volumename)s')
+                   % {'volumename':volumename})
+
+        # get volume instance from volumename on ETERNUS
+        try:
+            namelist = self.conn.EnumerateInstanceNames(
+                'FUJITSU_StorageVolume')
+        except:
+            msg=(_('_find_lun,'
+                   'volumename:%(volumename)s,'
+                   'EnumerateInstanceNames,'
+                   'cannot connect to ETERNUS.')
+                  % {'volumename':volumename})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        for name in namelist:
+            try:
+                vol_instance = self.conn.GetInstance(
+                    name)
+            except:
+                msg=(_('_find_lun,'
+                       'volumename:%(volumename)s,'
+                       'GetInstance,'
+                       'cannot connect to ETERNUS.')
+                      % {'volumename':volumename})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            if vol_instance['ElementName'] == volumename:
+                volumeinstance = vol_instance
+
+                LOG.debug(_('*****_find_lun,'
+                            'volumename:%(volumename)s,'
+                            'vol_instance:%(vol_instance)s.')
+                         % {'volumename': volumename,
+                            'vol_instance': str(volumeinstance.path)})
+                break
+            # end of if
+        else:
+            LOG.debug(_('*****_find_lun,'
+                        'volumename:%(volumename)s,'
+                        'volume not found on ETERNUS.')
+                       % {'volumename': volumename})
+        # end of for namelist
+
+        LOG.debug(_('*****_find_lun,Exit method'))
+
+        #return volume instance
+        return volumeinstance
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_copysession                                                                   #
+    #         summary      : find copysession from volumename on ETERNUS                           #
+    #         parameters   : volumename                                                            #
+    #         return-value : volume instance                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_copysession(self, volumename):
+        '''
+        find copysession from volumename on ETERNUS
+        '''
+        # cpsession              : copysession
+        # vol_instance           : volume instance
+        # repservice             : FUJITSU_ReplicationService
+        # rc                     : Invoke Method return code
+        # replicarellist         : copysession information list
+        # replicales             : copysession information
+        # snapshot_vol_instance  : snapshot volume instance
+        # msg                    : message
+        # errordesc              : error description
+        # cpsession_instance     : copysession instance
+
+        LOG.debug(_('*****_find_copysession,'
+                    'volumename:%s,'
+                    'Enter method')
+                   % volumename)
+
+        # initialize
+        cpsession             = None
+        vol_instance          = None
+        repservice            = None
+        rc                    = 0
+        replicarellist        = None
+        replicarel            = None
+        snapshot_vol_instance = None
+        msg                   = None
+        errordesc             = None
+        cpsession_instance    = None
+        # main processing
+        vol_instance = self._find_lun(volumename)
+        if vol_instance is not None:
+            # find target_volume
+
+            # get copysession list
+            repservice = self._find_eternus_service(REPL)
+            if repservice is None:
+                msg = (_('_find_copysession,'
+                         'Cannot find Replication Service to '
+                         'find copysession'))
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+            # end of if
+
+
+            # find copysession for source_volume
+            while True:
+                LOG.debug(_('*****_find_copysession,source_volume while copysession'))
+                cpsession = None
+
+                rc, errordesc, replicarellist = self._exec_eternus_service(
+                    'GetReplicationRelationships',
+                    repservice,
+                    Type=pywbem.Uint16(2),
+                    Mode=pywbem.Uint16(2),
+                    Locality=pywbem.Uint16(2))
+
+                if rc != 0L:
+                    msg = (_('_find_copysession,'
+                             'source_volumename:%(volumename)s,'
+                             'Return code:%(rc)lu,'
+                             'Error:%(errordesc)s')
+                            % {'volumename': volumename,
+                               'rc': rc,
+                               'errordesc':errordesc})
+                    LOG.error(msg)
+                    raise exception.VolumeBackendAPIException(data=msg)
+                # end of if
+
+                for replicarel in replicarellist['Synchronizations']:
+                    LOG.debug(_('*****_find_copysession,'
+                                'source_volume,'
+                                'replicarel:%(replicarel)s')
+                              % {'replicarel':replicarel})
+                    try:
+                        snapshot_vol_instance = self.conn.GetInstance(
+                            replicarel['SystemElement'],
+                            LocalOnly=False)
+                    except:
+                        msg=(_('_find_copysession,'
+                               'source_volumename:%(volumename)s,'
+                               'GetInstance,'
+                               'cannot connect to ETERNUS.')
+                              % {'volumename': volumename})
+                        LOG.error(msg)
+                        raise exception.VolumeBackendAPIException(data=msg)
+
+                    LOG.debug(_('*****_find_copysession,'
+                                'snapshot ElementName:%(elementname)s,'
+                                'source_volumename:%(volumename)s')
+                               % {'elementname': snapshot_vol_instance['ElementName'],
+                                  'volumename': volumename})
+
+                    if volumename == snapshot_vol_instance['ElementName']:
+                        #find copysession
+                        cpsession = replicarel
+                        LOG.debug(_('*****_find_copysession,'
+                                    'volumename:%(volumename)s,'
+                                    'Storage Synchronized instance:%(sync)s')
+                                 % {'volumename': volumename,
+                                    'sync': str(cpsession)})
+                        msg=(_('_find_copy_session,'
+                               'source_volumename:%(volumename)s,'
+                               'wait for end of copysession')
+                              % {'volumename': volumename})
+                        LOG.info(msg)
+
+                        try:
+                            cpsession_instance = self.conn.GetInstance(
+                                replicarel)
+                        except:
+                            break
+
+                        LOG.debug(_('*****_find_copysession,'
+                                    'status:%(status)s')
+                                  % {'status':cpsession_instance['CopyState']})
+                        if cpsession_instance['CopyState'] == BROKEN:
+                            msg=(_('_find_copysession,'
+                                   'source_volumename:%(volumename)s,'
+                                   'copysession state is BROKEN')
+                                  % {'volumename': volumename})
+                            LOG.error(msg)
+                            raise exception.VolumeBackendAPIException(data=msg)
+                        # end of if
+                        time.sleep(10)
+                        break
+                    # end of if
+                else:
+                    LOG.debug(_('*****_find_copysession,'
+                                'volumename:%(volumename)s,'
+                                'Storage Synchronized not found.')
+                               % {'volumename': volumename})
+                # end of for replicarellist
+                if cpsession is None:
+                    break
+            # end of while
+
+            # find copysession for target_volume
+            for replicarel in replicarellist['Synchronizations']:
+                LOG.debug(_('*****_find_copysession,'
+                            'replicarel:%(replicarel)s')
+                          % {'replicarel':replicarel})
+
+                # target volume
+                try:
+                    snapshot_vol_instance = self.conn.GetInstance(
+                        replicarel['SyncedElement'],
+                        LocalOnly=False)
+                except:
+                    msg=(_('_find_copysession,'
+                           'target_volumename:%(volumename)s,'
+                           'GetInstance,'
+                           'cannot connect to ETERNUS.')
+                          % {'volumename': volumename})
+                    LOG.error(msg)
+                    raise exception.VolumeBackendAPIException(data=msg)
+                LOG.debug(_('*****_find_copysession,'
+                            'snapshot ElementName:%(elementname)s,'
+                            'volumename:%(volumename)s')
+                           % {'elementname': snapshot_vol_instance['ElementName'],
+                              'volumename': volumename})
+
+                if volumename == snapshot_vol_instance['ElementName']:
+                    # find copysession
+                    cpsession = replicarel
+                    LOG.debug(_('*****_find_copysession,'
+                                'volumename:%(volumename)s,'
+                                'Storage Synchronized instance:%(sync)s')
+                             % {'volumename': volumename,
+                                'sync': str(cpsession)})
+                    break
+                # end of if
+
+            else:
+                LOG.debug(_('*****_find_copysession,'
+                            'volumename:%(volumename)s,'
+                            'Storage Synchronized not found.')
+                           % {'volumename': volumename})
+            # end of for replicarellist
+
+        else:
+            # does not find target_volume of copysession
+            msg = (_('_find_copysession,'
+                     'volumename:%(volumename)s,'
+                     'not found.')
+                    % {'volumename':volumename})
+            LOG.info(msg)
+        # end of if
+
+        LOG.debug(_('*****_find_copysession,Exit method'))
+
+        return cpsession
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _delete_copysession                                                                 #
+    #         summary      : delete copysession                                                    #
+    #         parameters   : copysession                                                           #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _delete_copysession(self,cpsession):
+        '''
+        delete copysession
+        '''
+        # cpsession         : copysession
+        # snapshot_instance : copysession instance
+        # operation         : 8  stop OPC and EC
+        #                   : 19 stop SnapOPC
+        # repjservice       : FUJITSU_ReplicationService
+        # msg               : message
+        # rc                : result of invoke method
+        # errordesc         : error message
+        # job               : unused
+
+        LOG.debug(_('*****_delete_copysession,Entering'))
+        LOG.debug(_('*****_delete_copysession,[%s]') % cpsession)
+
+        # initialize
+        operation         = 0
+        snapshot_instance = None
+        repservice        = None
+        msg               = None
+        rc                = 0
+        errordesc         = None
+        job               = None
+
+        # main processing
+
+        # get copysession type
+        # 4:SnapOPC, 5:OPC
+        try:
+            snapshot_instance = self.conn.GetInstance(
+                cpsession,
+                LocalOnly=False)
+        except:
+            msg=(_('_delete_copysession,'
+                   'copysession:%(cpsession)s,'
+                   'GetInstance,'
+                   'cannot connect to ETERNUS.')
+                  % {'cpsession':cpsession})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        copytype = snapshot_instance['CopyType']
+
+        # set oparation code
+        # 19:SnapOPC. 8:OPC
+        operation = OPERATION_dic[copytype]
+
+        repservice = self._find_eternus_service(REPL)
+        if repservice is None:
+            msg = (_('_delete_copysession,'
+                     'Cannot find Replication Service to '
+                     'delete copysession'))
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        # Invoke method for delete copysession
+        rc, errordesc, job = self._exec_eternus_service(
+            'ModifyReplicaSynchronization',
+            repservice,
+            Operation=pywbem.Uint16(operation),
+            Synchronization=cpsession,
+            Force=True,
+            WaitForCopyState=pywbem.Uint16(15))
+
+        LOG.debug(_('*****_delete_copysession,'
+                    'copysession:%(cpsession)s,'
+                    'operation:%(operation)s,'
+                    'Return code:%(rc)lu,'
+                    'Error:%(errordesc)s,'
+                    'Exit method')
+                   % {'cpsession': cpsession,
+                      'operation': operation,
+                      'rc': rc,
+                      'errordesc': errordesc})
+
+        if rc != 0L:
+            msg = (_('_delete_copysession,'
+                     'copysession:%(cpsession)s,'
+                     'operation:%(operation)s,'
+                     'Return code:%(rc)lu,'
+                     'Error:%(errordesc)s')
+                    % {'cpsession': cpsession,
+                       'operation': operation,
+                       'rc': rc,
+                       'errordesc': errordesc})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _get_target_portid                                                                  #
+    #         summary      : return target_portid                                                  #
+    #         parameters   : connector                                                             #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _get_target_portid(self, connector):
+        '''
+        return target_portid
+        '''
+        # target_portidlist : target_portid list
+        # tgtportlist       : target port list
+        # tgtport           : target port
+
+        LOG.debug(_('*****_get_target_portid,Enter method'))
+
+        # initialize
+        target_portidlist = []
+        tgtportlist       = []
+        tgtport           = None
+
+        # main processing
+        if self.protocol == 'fc':
+            # Protocol id FibreChannel
+            try:
+                tgtportlist = self.conn.EnumerateInstances(
+                    'FUJITSU_SCSIProtocolEndpoint')
+            except:
+                msg=(_('_get_target_portid,'
+                       'connector:%(connector)s,'
+                       'EnumerateInstances,'
+                       'cannot connect to ETERNUS.')
+                      % {'connector':connector})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            for tgtport in tgtportlist:
+                if tgtport['ConnectionType'] == 2:
+                    target_portidlist.append(tgtport['Name'])
+
+                LOG.debug(_('*****_get_target_portid,'
+                            'wwn:%(wwn)s,'
+                            'connection type:%(cont)s,'
+                            'ramode:%(ramode)s')
+                           % {'wwn': tgtport['Name'],
+                              'cont': tgtport['ConnectionType'],
+                              'ramode': tgtport['RAMode']})
+            # end of for tgtportlist
+
+            LOG.debug(_('*****_get_target_portid,'
+                        'target wwns: %(target_portid)s ')
+                       % {'target_portid': target_portidlist})
+
+        elif self.protocol == 'iSCSI':
+            # Protocol is iSCSI
+            try:
+                tgtportlist = self.conn.EnumerateInstances(
+                    'FUJITSU_iSCSIProtocolEndpoint')
+            except:
+                msg=(_('_get_target_portid,'
+                       'connector:%(connector)s,'
+                       'EnumerateInstances,'
+                       'cannot connect to ETERNUS.')
+                      % {'connector':connector})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            for tgtport in tgtportlist:
+                if tgtport['ConnectionType'] == 7:
+                    target_portidlist.append(tgtport['Name'])
+                LOG.debug(_('*****_get_target_portid,'
+                            'iSCSIname:%(iscsiname)s,'
+                            'connection type:%(cont)s,'
+                            'ramode: %(ramode)s')
+                           % {'iscsiname': tgtport['Name'],
+                              'cont': tgtport['ConnectionType'],
+                              'ramode': tgtport['RAMode']})
+            # end of for tgtportlist
+
+            LOG.debug(_('*****_get_target_portid,'
+                        'target iSCSIname: %(target_portid)s ')
+                       % {'target_portid': target_portidlist})
+        # end of if
+
+        if len(target_portidlist) == 0:
+            msg = (_('_get_target_portid,'
+                     'protcol:%(protocol)s,'
+                     'connector:%(connector)s,'
+                     'target_portid does not found.')
+                   % {'protocol': self.protocol,
+                      'connector': connector})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+
+        LOG.debug(_('*****_get_target_portid,Exit method'))
+
+        return target_portidlist
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _map_lun                                                                             #
+    #         summary      : map volume to host                                                    #
+    #         parameters   : volume, connector, targetlist                                         #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _map_lun(self, volume, connector, targetlist = []):
+        '''
+        map volume to host.
+        '''
+        # vol_instance : volume instance
+        # volumename   : volume name on ETERNUS
+        # volume_uid   : volume UID
+        #                ex)600000E00D110000001104EC00DB0000
+        # initiatorlist: inisiator id
+        #                ex)[u'10000000c978c574', u'10000000c978c575']
+        # targetlist   : ETERNUS target id
+        #                ex)[u'500000E0D444EC80', u'500000E0D444EC81']
+        # aglist       : assigned AffinityGroup list
+        # ag           : AffinityGroup
+        # configservice: FUJITSU_StorageConfigurationService
+        # msg          : message
+        # rc           : result of invoke method
+        # errordesc    : error message
+        # job          : unused
+
+        LOG.debug(_('*****_map_lun,'
+                    'volume:%(volume)s,'
+                    'connector:%(con)s,'
+                    'Enter method')
+                   % {'volume': volume['display_name'],
+                      'con': connector})
+
+        # initialize
+        vol_instance  = None
+        volumename    = None
+        volume_uid    = None
+        initiatorlist = []
+        target        = None
+        aglist        = []
+        ag            = None
+        configservice = None
+        msg           = None
+        rc            = 0
+        errordesc     = None
+        job           = None
+
+        # main processing
+        volumename    = self._create_volume_name(volume['id'])
+        vol_instance  = self._find_lun(volumename)
+        volume_uid    = vol_instance['Name']
+        initiatorlist = self._find_initiator_names(connector)
+        aglist        = self._find_affinity_group(connector)
+        configservice = self._find_eternus_service(CTRL_CONF)
+
+        if len(targetlist) == 0:
+            targetlist = self._get_target_portid(connector)
+        # end of if
+
+        if configservice is None:
+            msg = (_('_map_lun,'
+                     'vol_instance.path:%(vol)s,'
+                     'volumename:%(volumename)s,'
+                     'volume_uid:%(uid)s,'
+                     'initiator:%(initiator)s,'
+                     'target:%(tgt)s',
+                     'aglist:%(aglist)s',
+                     'Cannot find Controller Configuration')
+                    % {'vol': str(vol_instance.path),
+                       'volumename': [volumename],
+                       'uid': [volume_uid],
+                       'initiator': initiatorlist,
+                       'tgt': targetlist,
+                       'aglist': aglist})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+        LOG.debug(_('*****_map_lun,'
+                    'vol_instance.path:%(vol)s,'
+                    'volumename:%(volumename)s,'
+                    'initiator:%(initiator)s,'
+                    'target:%(tgt)s')
+                  % {'vol': str(vol_instance.path),
+                     'volumename': [volumename],
+                     'initiator': initiatorlist,
+                     'tgt': targetlist})
+
+        if len(aglist) == 0:
+            # create new affinity group
+            for target in targetlist:
+                LOG.debug(_('*****_map_lun,'
+                            'lun_name:%(volume_uid)s,'
+                            'Initiator:%(initiator)s,'
+                            'target:%(tgt)s')
+                           % {'volume_uid': [volume_uid],
+                              'initiator': initiatorlist,
+                              'tgt': target})
+
+                rc, errordesc, job = self._exec_eternus_service(
+                    'ExposePaths',
+                    configservice,
+                    LUNames=[volume_uid],
+                    InitiatorPortIDs=initiatorlist,
+                    TargetPortIDs=[target],
+                    DeviceAccesses=[pywbem.Uint16(2)])
+
+                LOG.debug(_('*****_map_lun,'
+                            'Error:%(errordesc)s,'
+                            'Return code:%(rc)lu,'
+                            'Create new affinitygroup')
+                           % {'errordesc':errordesc,
+                              'rc':rc})
+
+                if rc != 0L:
+                    msg = (_('_map_lun,'
+                             'lun_name:%(volume_uid)s,'
+                             'Initiator:%(initiator)s,'
+                             'target:%(tgt)s,'
+                             'Return code:%(rc)lu,'
+                             'Error:%(errordesc)s')
+                            % {'volume_uid': [volume_uid],
+                               'initiator': initiatorlist,
+                               'tgt': target,
+                               'rc': rc,
+                               'errordesc':errordesc})
+                    LOG.warn(msg)
+                # end of if
+            # end of for targetlist
+        else:
+            # add lun to affinity group
+            for ag in aglist:
+                LOG.debug(_('*****_map_lun,'
+                            'ag:%(ag)s,'
+                            'lun_name:%(volume_uid)s')
+                           % {'ag': str(ag),
+                              'volume_uid':volume_uid})
+
+                rc, errordesc, job = self._exec_eternus_service(
+                    'ExposePaths',
+                    configservice, LUNames=[volume_uid],
+                    DeviceAccesses=[pywbem.Uint16(2)],
+                    ProtocolControllers=[ag])
+
+                LOG.debug(_('*****_map_lun,'
+                            'Error:%(errordesc)s,'
+                            'Return code:%(rc)lu,'
+                            'Add lun affinitygroup')
+                           % {'errordesc':errordesc,
+                              'rc':rc})
+
+                if rc != 0L:
+                    msg = (_('_map_lun,'
+                             'lun_name:%(volume_uid)s,'
+                             'Initiator:%(initiator)s,'
+                             'target:%(tgt)s,'
+                             'Return code:%(rc)lu,'
+                             'Error:%(errordesc)s')
+                            % {'volume_uid': [volume_uid],
+                               'initiator': initiatorlist,
+                               'tgt': target,
+                               'rc': rc,
+                               'errordesc':errordesc})
+                    LOG.warn(msg)
+                # end of if
+            # end of for aglist
+        # end of if
+        LOG.debug(_('*****_map_lun,'
+                    'volumename:%(volumename)s,'
+                    'Exit method')
+                   % {'volumename':volumename})
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_initiator_names                                                               #
+    #         summary      : return initiator names                                                #
+    #         parameters   : connector                                                             #
+    #         return-value : initiator name                                                        #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_initiator_names(self, connector):
+        '''
+        return initiator names
+        '''
+        # initiatornamelist : initiator name
+        # msg               : None
+
+        LOG.debug(_('*****_find_initiator_names,Enter method'))
+
+        # initialize
+        initiatornamelist = []
+        msg               = None
+
+        # main processing
+        if self.protocol == 'iSCSI' and connector['initiator'] is not None:
+            initiatornamelist.append(connector['initiator'])
+        elif self.protocol == 'fc' and connector['wwpns'] is not None:
+            initiatornamelist = connector['wwpns']
+        # end of if
+        if len(initiatornamelist) == 0:
+            msg = (_('_find_initiator_names,'
+                     'connector:%(connector)s,'
+                     'not found initiator')
+                    % {'connector':connector})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+        LOG.debug(_('*****_find_initiator_names,'
+                    'initiator:%(initiator)s.'
+                    'Exit method')
+                  % {'initiator': initiatornamelist})
+
+        return initiatornamelist
+
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _find_affinity_group                                                                #
+    #         summary      : return affinity group from connector                                  #
+    #         parameters   : connector, vol_instance                                               #
+    #         return-value : initiator name                                                        #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _find_affinity_group(self,connector,vol_instance=None):
+        '''
+        find affinity group from connector
+        '''
+        # affinity_grouplist: affinity group list(return value)
+        # initiatorlist     : initiator list
+        # initiator         : initiator
+        # aglist            : affinity group list(temp)
+        # ag                : affinity group
+        # hostaglist        : host affinity group information listr
+        # hostag            : host affinity group information
+
+        LOG.debug(_('*****_find_affinity_group,'
+                    'Enter method'))
+
+        # initialize
+        affinity_grouplist  = []
+        initiatorlist       = []
+        initiator           = None
+        aglist              = []
+        ag                  = None
+        hostaglist          = []
+        hostag              = None
+
+        # main processing
+        initiatorlist = self._find_initiator_names(connector)
+
+        if vol_instance is None:
+            try:
+                aglist = self.conn.EnumerateInstanceNames(
+                    'FUJITSU_AffinityGroupController')
+            except:
+                msg=(_('_find_affinity_group,'
+                       'connector:%(connector)s,'
+                       'EnumerateInstanceNames,'
+                       'cannot connect to ETERNUS.')
+                      % {'connector':connector})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            LOG.debug(_('*****_find_affinity_group,'
+                        'affinity_groups:%s')
+                       % aglist)
+        else:
+            try:
+                aglist = self.conn.AssociatorNames(
+                    vol_instance.path,
+                    AssocClass ='CIM_ProtocolControllerForUnit',
+                    ResultClass='FUJITSU_AffinityGroupController')
+            except:
+                msg=(_('_find_affinity_group,'
+                       'connector:%(connector)s,'
+                       'AssociatorNames,'
+                       'cannot connect to ETERNUS.')
+                      % {'connector':connector})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            LOG.debug(_('*****_find_affinity_group,'
+                        'vol_instance.path:%(vol)s,'
+                        'affinity_groups:%(aglist)s')
+                       % {'vol':vol_instance.path,
+                          'aglist':aglist})
+        # end of if
+        for ag in aglist:
+            try:
+                hostaglist = self.conn.Associators(
+                    ag,
+                    AssocClass ='CIM_AuthorizedTarget',
+                    ResultClass='FUJITSU_AuthorizedPrivilege')
+            except:
+                msg=(_('_find_affinity_group,'
+                       'connector:%(connector)s,'
+                       'Associators,'
+                       'cannot connect to ETERNUS.')
+                      % {'connector':connector})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            for hostag in hostaglist:
+                for initiator in initiatorlist:
+                    if initiator.lower() not in hostag['InstanceID'].lower():
+                        continue
+                    # end of if
+                    LOG.debug(_('*****_find_affinity_group,'
+                                'AffinityGroup:%(ag)s')
+                               % {'ag':ag})
+                    affinity_grouplist.append(ag)
+                    break
+                # end of for initiatorlist
+                break
+            # end of for hostaglist
+        # end of for aglist
+        LOG.debug(_('*****_find_affinity_group,'
+                    'initiators:%(initiator)s,'
+                    'affinity_group:%(affinity_group)s.'
+                    'Exit method')
+                   % {'initiator': initiatorlist,
+                      'affinity_group': affinity_grouplist})
+
+        return affinity_grouplist
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _unmap_lun                                                                          #
+    #         summary      : unmap volume from host                                                #
+    #         parameters   : volume, connector                                                     #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _unmap_lun(self, volume, connector):
+        '''
+        unmap volume from host
+        '''
+
+        # vol_instance : volume instance
+        # volumename   : volume name on ETERNUS
+        # volume_uid   : volume UID
+        #                ex)600000E00D110000001104EC00DB0000
+        # volmap       : volume map information
+        # aglist       : assigned AffinityGroup list
+        # ag           : AffinityGroup
+        # configservice: FUJITSU_StorageConfigurationService
+        # msg          : message
+        # rc           : result of invoke method
+        # errordesc    : error message
+        # job          : unused
+
+        LOG.debug(_('*****_unmap_lun,Enter method'))
+
+        # initialize
+        vol_instance   = None
+        volumename     = None
+        volume_uid     = None
+        volmap         = {}
+        device_number  = None
+        configservice  = None
+        msg            = None
+        aglist         = None
+        ag             = None
+        msg            = None
+        rc             = 0
+        errordesc      = None
+        job            = None
+
+        # main processing
+        volumename    = self._create_volume_name(volume['id'])
+        vol_instance  = self._find_lun(volumename)
+        if vol_instance is None:
+            LOG.info(_('_unmap_lun,'
+                       'volumename:%(volumename)s,'
+                       'volume not found.'
+                       'Exit method')
+                      % {'volumename':volumename})
+            return
+        # end of if
+        volume_uid    = vol_instance['Name']
+        volmap        = self._find_device_number(volume, connector)
+        configservice = self._find_eternus_service(CTRL_CONF)
+        aglist        = self._find_affinity_group(connector,vol_instance)
+
+        device_number = volmap['target_lun']
+        if device_number is None:
+            LOG.info(_('_unmap_lun,'
+                       'volumename:%(volumename)s,'
+                       'volume is not mapped.'
+                       'Exit method')
+                      % {'volumename':volumename})
+            return
+        # end of if
+        if configservice is None:
+            msg = (_('_unmap_lun,'
+                     'vol_instance.path:%(vol)s,'
+                     'volumename:%(volumename)s,'
+                     'volume_uid:%(uid)s,'
+                     'aglist:%(aglist)s',
+                     'Cannot find Controller Configuration')
+                    % {'vol': str(vol_instance.path),
+                       'volumename': [volumename],
+                       'uid': [volume_uid],
+                       'aglist': aglist})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of if
+        for ag in aglist:
+            LOG.debug(_('*****_unmap_lun,'
+                        'volumename:%(volumename)s,'
+                        'volume_uid:%(volume_uid)s,'
+                        'AffinityGroup:%(ag)s')
+                       % {'volumename': volumename,
+                          'volume_uid': volume_uid,
+                          'ag': ag})
+
+            rc, errordesc, job = self._exec_eternus_service(
+                'HidePaths',
+                configservice,
+                LUNames=[volume_uid],
+                ProtocolControllers=[ag])
+
+            LOG.debug(_('*****_unmap_lun,'
+                        'Error:%(errordesc)s,'
+                        'Return code:%(rc)lu')
+                       % {'errordesc':errordesc,
+                          'rc':rc})
+
+            if rc != 0L:
+                msg = (_('_unmap_lun,'
+                         'volumename:%(volumename)s,'
+                         'volume_uid:%(volume_uid)s,'
+                         'AffinityGroup:%(ag)s,'
+                         'Return code:%(rc)lu,'
+                         'Error:%(errordesc)s')
+                        % {'volumename': volumename,
+                           'volume_uid': volume_uid,
+                           'ag': ag,
+                           'rc': rc,
+                           'errordesc':errordesc})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+            # end of if
+        # end of for aglist
+        LOG.debug(_('*****_unmap_lun,'
+                    'volumename:%(volumename)s,'
+                    'Exit method')
+                   % {'volumename':volumename})
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : _get_iqn                                                                            #
+    #         summary      : get target iqn                                                        #
+    #         parameters   : iscsi ip address                                                      #
+    #         return-value : iqn                                                                   #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def _get_iqn(self):
+        '''
+        get target port iqn
+        '''
+        # iscsiip              : target iscsi ip address
+        # ip_endpointlist      : ip protocol endpoint list
+        # ip_endpoint          : ip protocol endpoint
+        # tcp_endpointlist     : tcp protocol endpoint list
+        # tcp_endpoint         : tcp protocol endpoint
+        # iscsi_endpointlist   : iscsi protocol endpoint list
+        # iscsi_endpoint       : iscsi protocol endpoint
+        # ip_endpoint_instance : ip protocol endpoint instance
+
+        LOG.debug(_('*****_get_iqn,Enter method'))
+
+        # initialize
+        iscsiip              = self.configuration.iscsi_ip_address
+        ip_endpointlist      = []
+        ip_endpoint          = None
+        tcp_endpointlist     = []
+        tcp_endpoint         = None
+        iscsi_endpointlist   = []
+        iscsi_endpoint       = None
+        ip_endpoint_instance = None
+
+        if iscsiip is None:
+            iscsiip = self._get_drvcfg('EternusISCSIIP')
+        # end of if
+        try:
+            ip_endpointlist = self.conn.EnumerateInstanceNames(
+                'FUJITSU_IPProtocolEndpoint')
+        except:
+            msg=(_('_get_iqn,'
+                   'iscsiip:%(iscsiip)s,'
+                   'EnumerateInstanceNames,'
+                   'cannot connect to ETERNUS.')
+                  % {'iscsiip':iscsiip})
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+
+        for ip_endpoint in ip_endpointlist:
+            try:
+                ip_endpoint_instance = self.conn.GetInstance(
+                    ip_endpoint)
+                LOG.debug(_('*****_get_iqn,'
+                            'ip_endpoint_instance[IPv4Address]:%(ip_endpoint_instance)s,'
+                            'iscsiip:%(iscsiip)s')
+                           % {'ip_endpoint_instance':ip_endpoint_instance['IPv4Address'],
+                              'iscsiip':iscsiip})
+            except:
+                msg=(_('_get_iqn,'
+                       'iscsiip:%(iscsiip)s,'
+                       'GetInstance,'
+                       'cannot connect to ETERNUS.')
+                      % {'iscsiip':iscsiip})
+                LOG.error(msg)
+                raise exception.VolumeBackendAPIException(data=msg)
+
+            if ip_endpoint_instance['IPv4Address'] != iscsiip:
+                continue
+            else:
+                LOG.debug(_('*****_get_iqn,find iscsiip'))
+                try:
+                    tcp_endpointlist = self.conn.AssociatorNames(
+                        ip_endpoint,
+                        ResultClass='FUJITSU_TCPProtocolEndpoint')
+                except:
+                    msg=(_('_get_iqn,'
+                           'iscsiip:%(iscsiip)s,'
+                           'AssociatorNames,'
+                           'cannot connect to ETERNUS.')
+                          % {'iscsiip':iscsiip})
+                    LOG.error(msg)
+                    raise exception.VolumeBackendAPIException(data=msg)
+
+                for tcp_endpoint in tcp_endpointlist:
+                    try:
+                        iscsi_endpointlist = self.conn.Associators(
+                            tcp_endpoint,
+                            ResultClass='FUJITSU_iSCSIProtocolEndpoint')
+                    except:
+                        msg=(_('_get_iqn,'
+                               'iscsiip:%(iscsiip)s,'
+                               'AssociatorNames,'
+                               'cannot connect to ETERNUS.')
+                              % {'iscsiip':iscsiip})
+                        LOG.error(msg)
+                        raise exception.VolumeBackendAPIException(data=msg)
+
+                    for iscsi_endpoint in iscsi_endpointlist:
+                        iqn = iscsi_endpoint['Name'].split(',')[0]
+                        LOG.debug(_('*****_get_iqn,'
+                                    'iscsi_endpoint[Name]:%(iscsi_endpoint)s')
+                                   % {'iscsi_endpoint':iscsi_endpoint['Name']})
+                        break
+                    # end of for iscsi_endpointlist
+                    break
+                # end of for tcp_endpointlist
+            # end of if
+            break
+        # end of for ip_endpoint
+        else:
+            msg = (_('_get_iqn,'
+                     'iscsiip:%(iscsiip)s,'
+                     'not found iqn')
+                    % {'iscsiip':iscsiip})
+
+            LOG.error(msg)
+            raise exception.VolumeBackendAPIException(data=msg)
+        # end of for ip_endpointlist
+        LOG.debug(_('*****_get_iqn,%s,Exit method') % iqn )
+        return iqn
+
Index: cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_fc.py
===================================================================
--- /dev/null
+++ cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_fc.py
@@ -0,0 +1,430 @@
+# Copyright (c) 2014 FUJITSU LIMITED
+# Copyright (c) 2012 EMC Corporation.
+# Copyright (c) 2012 OpenStack Foundation
+# 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.
+#
+
+'''
+FibreChannel Cinder Volume driver for Fujitsu ETERNUS DX S2 and S3 series.
+'''
+
+##------------------------------------------------------------------------------------------------##
+##                                                                                                ##
+##  ETERNUS OpenStack Volume Driver                                                               ##
+##                                                                                                ##
+##  Note      :                                                                                   ##
+##  File Name : fujitsu_eternus_dx_fc.py                                                          ##
+##  Copyright 2014 FUJITSU LIMITED                                                                ##
+##                                                                                                ##
+##  history :                                                                                     ##
+##      2014.03 : 1.0.0 : volume(create,delete,attach,detach,create from snapshot)                ##
+##                        snapshot(create,delete)                                                 ##
+##      2014.04 : 1.0.1 : Fix comment                                                             ##
+##      2014.06 : 1.1.0 : Support 4 features                                                      ##
+##                         Extend volume                                                          ##
+##                         Clone Volume                                                           ##
+##                         Copy Image to Volume                                                   ##
+##                         Copy Volume to Image                                                   ##
+##------------------------------------------------------------------------------------------------##
+
+
+from oslo.config import cfg
+from cinder.openstack.common import log as logging
+from cinder import exception
+from cinder.volume import driver
+from cinder.openstack.common import lockutils
+from cinder.volume.drivers.fujitsu import fujitsu_eternus_dx_common
+import time
+
+LOG = logging.getLogger(__name__)
+
+#--------------------------------------------------------------------------------------------------#
+# Class : FJDXFCDriver                                                                             #
+#         summary      : fibrechannel cinder volume driver for Fujitsu ETERNUS DX                  #
+#--------------------------------------------------------------------------------------------------#
+class FJDXFCDriver(driver.FibreChannelDriver):
+    '''
+    ETERNUS Cinder Volume Driver version1.0
+    for Fujitsu ETERNUS DX S2 and S3 series
+    '''
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : __init__                                                                            #
+    #         summary      :                                                                       #
+    #         parameters   :                                                                       #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def __init__(self, *args, **kwargs):
+        '''
+        Constructor
+        '''
+        super(FJDXFCDriver, self).__init__(*args, **kwargs)
+        self.common = fujitsu_eternus_dx_common.FJDXCommon(
+            'fc',
+            configuration=self.configuration)
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : check_for_setup_error                                                               #
+    #         summary      :                                                                       #
+    #         parameters   :                                                                       #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def check_for_setup_error(self):
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_volume                                                                       #
+    #         summary      : create volume on ETERNUS                                              #
+    #         parameters   : volume                                                                #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_volume(self, volume):
+        '''
+        Create volume
+        '''
+        LOG.debug(_('*****create_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        metadata         = None
+        v_metadata       = None
+        data             = None
+
+        enter_time = time.time()
+        metadata = self.common.create_volume(volume)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        v_metadata = volume.get('volume_metadata')
+        for data in v_metadata:
+            metadata[data['key']] = data['value']
+
+        return {'metadata': metadata}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_volume_from_snapshot                                                         #
+    #         summary      : create volume from snapshot                                           #
+    #         parameters   : volume, snapshot                                                      #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_volume_from_snapshot(self, volume, snapshot):
+        '''
+        Creates a volume from a snapshot.
+        '''
+        LOG.debug(_('*****creaet_volume_from_snapshot,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        metadata         = None
+        v_metadata       = None
+        data             = None
+
+        enter_time = time.time()
+        metadata = self.common.create_volume_from_snapshot(volume, snapshot)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_volume_from_snapshot,'
+                    'processing time:%s sec') % processing_time)
+
+        v_metadata = volume.get('volume_metadata')
+        for data in v_metadata:
+            metadata[data['key']] = data['value']
+
+        return {'metadata': metadata}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_cloned_volume                                                                #
+    #         summary      : create cloned volume on ETERNUS                                       #
+    #         parameters   : volume, src_vref                                                      #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_cloned_volume(self, volume, src_vref):
+        """Create cloned volume."""
+        LOG.debug(_('*****create_cloned_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        metadata         = None
+        v_metadata       = None
+        data             = None
+
+        enter_time = time.time()
+        metadata = self.common.create_cloned_volume(volume, src_vref)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_cloned_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        v_metadata = volume.get('volume_metadata')
+        for data in v_metadata:
+            metadata[data['key']] = data['value']
+
+        return {'metadata': metadata}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : delete_volume                                                                       #
+    #         summary      : delete volume on ETERNUS                                              #
+    #         parameters   : volume                                                                #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def delete_volume(self, volume):
+        '''
+        Delete volume on ETERNUS.
+        '''
+        LOG.debug(_('*****delete_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.delete_volume(volume)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****delete_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_snapshot                                                                     #
+    #         summary      : create snapshot using SnapOPC                                         #
+    #         parameters   : snapshot                                                              #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_snapshot(self, snapshot):
+        '''
+        Creates a snapshot.
+        '''
+        LOG.debug(_('*****create_snapshot,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.create_snapshot(snapshot)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_snapshot,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : delete_snapshot                                                                     #
+    #         summary      : delete snapshot                                                       #
+    #         parameters   : snapshot                                                              #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def delete_snapshot(self, snapshot):
+        '''
+        Deletes a snapshot.
+        '''
+        LOG.debug(_('*****delete_snapshot,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.delete_snapshot(snapshot)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****delete_snapshot,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : ensure_export                                                                       #
+    #         summary      : Driver entry point to get the export info for an existing volume.     #
+    #         parameters   : context, volume                                                       #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def ensure_export(self, context, volume):
+        """Driver entry point to get the export info for an existing volume."""
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_export                                                                       #
+    #         summary      : Driver entry point to get the export info for a new volume.           #
+    #         parameters   : context, volume                                                       #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def create_export(self, context, volume):
+        """Driver entry point to get the export info for a new volume."""
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : remove_export                                                                       #
+    #         summary      : Driver entry point to remove an export for a volume.                  #
+    #         parameters   : context, volume                                                       #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def remove_export(self, context, volume):
+        """Driver entry point to remove an export for a volume."""
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : initialize_connection                                                               #
+    #         summary      : set HostAffinityGroup on ETERNUS                                      #
+    #         parameters   : volume, connector                                                     #
+    #         return-value : connection info                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def initialize_connection(self, volume, connector):
+        '''
+        Allow connection to connector and return connection info.
+        '''
+        LOG.debug(_('*****initialize_connection,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        info = self.common.initialize_connection(volume, connector)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****initialize_connection,'
+                    'processing time:%s sec') % processing_time)
+
+        return info
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : terminate_connection                                                                #
+    #         summary      : remove HostAffinityGroup on ETERNUS                                   #
+    #         parameters   : volume, connector                                                     #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def terminate_connection(self, volume, connector, **kwargs):
+        '''
+        Disallow connection from connector.
+        '''
+        LOG.debug(_('*****terminate_connection,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.terminate_connection(volume, connector)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****terminate_connection,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : get_volume_stats                                                                    #
+    #         summary      : get pool capacity                                                     #
+    #         parameters   : refresh                                                               #
+    #         return-value : self.stats                                                            #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def get_volume_stats(self, refresh=False):
+        '''
+        Get volume stats.
+        If 'refresh' is True, run update the stats first.
+        '''
+        LOG.debug(_('*****get_volume_stats,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        if refresh == True:
+            data                        = self.common.refresh_volume_stats()
+            backend_name                = self.configuration.safe_get('volume_backend_name')
+            data['volume_backend_name'] = backend_name or 'FJDXFCDriver'
+            data['storage_protocol']    = 'fibre_channel'
+            self._stats                 = data
+        # end of if
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****get_volume_stats,'
+                    'processing time:%s sec') % processing_time)
+
+        return self._stats
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : extend_volume                                                                       #
+    #         summary      : extend volume on ETERNUS                                              #
+    #         parameters   : volume, new_size                                                      #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def extend_volume(self, volume, new_size):
+        '''
+        Extend volume.
+        '''
+        LOG.debug(_('*****extend_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+
+        enter_time = time.time()
+        self.common.extend_volume(volume, new_size)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****extend_volume,'
+                    'processing time:%s sec') % processing_time)
+        return
Index: cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_iscsi.py
===================================================================
--- /dev/null
+++ cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_iscsi.py
@@ -0,0 +1,440 @@
+﻿# Copyright (c) 2014 FUJITSU LIMITED
+# Copyright (c) 2012 EMC Corporation.
+# Copyright (c) 2012 OpenStack Foundation
+# 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.
+#
+
+'''
+iSCSI Cinder Volume driver for Fujitsu ETERNUS DX S2 and S3 series.
+'''
+
+##------------------------------------------------------------------------------------------------##
+##                                                                                                ##
+##  ETERNUS OpenStack Volume Driver                                                               ##
+##                                                                                                ##
+##  Note      :                                                                                   ##
+##  File Name : fujitsu_eternus_dx_iscsi.py                                                       ##
+##  Copyright 2014 FUJITSU LIMITED                                                                ##
+##                                                                                                ##
+##  history :                                                                                     ##
+##      2014.03 : 1.0.0 : volume(create,delete,attach,detach,create from snapshot)                ##
+##                        snapshot(create,delete)                                                 ##
+##      2014.04 : 1.0.1 : Fix comment                                                             ##
+##      2014.06 : 1.1.0 : Support 4 features                                                      ##
+##                         Extend volume                                                          ##
+##                         Clone Volume                                                           ##
+##                         Copy Image to Volume                                                   ##
+##                         Copy Volume to Image                                                   ##
+##------------------------------------------------------------------------------------------------##
+
+
+from oslo.config import cfg
+from cinder.openstack.common import log as logging
+from cinder import exception
+from cinder.volume import driver
+from cinder.openstack.common import lockutils
+from cinder.volume.drivers.fujitsu import fujitsu_eternus_dx_common
+import time
+
+LOG = logging.getLogger(__name__)
+
+#--------------------------------------------------------------------------------------------------#
+# Class : FJDXISCSIDriver                                                                          #
+#         summary      : iSCSI cinder volume driver for Fujitsu ETERNUS DX                         #
+#--------------------------------------------------------------------------------------------------#
+class FJDXISCSIDriver(driver.ISCSIDriver):
+    '''
+    ETERNUS Cinder Volume Driver version1.0
+    for Fujitsu ETERNUS DX S2 and S3 series
+    '''
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : __init__                                                                            #
+    #         summary      :                                                                       #
+    #         parameters   :                                                                       #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def __init__(self, *args, **kwargs):
+        '''
+        Constructor
+        '''
+        super(FJDXISCSIDriver, self).__init__(*args, **kwargs)
+        self.common = fujitsu_eternus_dx_common.FJDXCommon(
+            'iSCSI',
+            configuration=self.configuration)
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : check_for_setup_error                                                               #
+    #         summary      :                                                                       #
+    #         parameters   :                                                                       #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def check_for_setup_error(self):
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_volume                                                                       #
+    #         summary      : create volume on ETERNUS                                              #
+    #         parameters   : volume                                                                #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_volume(self, volume):
+        '''
+        Create volume
+        '''
+        LOG.debug(_('*****create_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        metadata         = None
+        v_metadata       = None
+        data             = None
+
+        enter_time = time.time()
+        metadata = self.common.create_volume(volume)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        v_metadata = volume.get('volume_metadata')
+        for data in v_metadata:
+            metadata[data['key']] = data['value']
+
+        return {'provider_location': "%s:%s" %
+                (self.configuration.iscsi_ip_address,
+                 self.configuration.iscsi_port),
+                'metadata': metadata}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_volume_from_snapshot                                                         #
+    #         summary      : create volume from snapshot                                           #
+    #         parameters   : volume, snapshot                                                      #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_volume_from_snapshot(self, volume, snapshot):
+        '''
+        Creates a volume from a snapshot.
+        '''
+        LOG.debug(_('*****creaet_volume_from_snapshot,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        metadata         = None
+        v_metadata       = None
+        data             = None
+
+        enter_time = time.time()
+        metadata = self.common.create_volume_from_snapshot(volume, snapshot)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_volume_from_snapshot,'
+                    'processing time:%s sec') % processing_time)
+
+        v_metadata = volume.get('volume_metadata')
+        for data in v_metadata:
+            metadata[data['key']] = data['value']
+
+        return {'provider_location': "%s:%s" %
+                (self.configuration.iscsi_ip_address,
+                 self.configuration.iscsi_port),
+                'metadata': metadata}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_cloned_volume                                                                #
+    #         summary      : create cloned volume on ETERNUS                                       #
+    #         parameters   : volume, src_vref                                                      #
+    #         return-value : volume metadata                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_cloned_volume(self, volume, src_vref):
+        """Create cloned volume."""
+        LOG.debug(_('*****creaet_cloned_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        metadata         = None
+        v_metadata       = None
+        data             = None
+
+        enter_time = time.time()
+        metadata = self.common.create_cloned_volume(volume, src_vref)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_cloned_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        v_metadata = volume.get('volume_metadata')
+        for data in v_metadata:
+            metadata[data['key']] = data['value']
+
+        return {'provider_location': "%s:%s" %
+                (self.configuration.iscsi_ip_address,
+                 self.configuration.iscsi_port),
+                'metadata': metadata}
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : delete_volume                                                                       #
+    #         summary      : delete volume on ETERNUS                                              #
+    #         parameters   : volume                                                                #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def delete_volume(self, volume):
+        '''
+        Delete volume on ETERNUS.
+        '''
+        LOG.debug(_('*****delete_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.delete_volume(volume)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****delete_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_snapshot                                                                     #
+    #         summary      : create snapshot using SnapOPC                                         #
+    #         parameters   : snapshot                                                              #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def create_snapshot(self, snapshot):
+        '''
+        Creates a snapshot.
+        '''
+        LOG.debug(_('*****create_snapshot,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.create_snapshot(snapshot)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****create_snapshot,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : delete_snapshot                                                                     #
+    #         summary      : delete snapshot                                                       #
+    #         parameters   : snapshot                                                              #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def delete_snapshot(self, snapshot):
+        '''
+        Deletes a snapshot.
+        '''
+        LOG.debug(_('*****delete_snapshot,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.delete_snapshot(snapshot)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****delete_snapshot,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : ensure_export                                                                       #
+    #         summary      : Driver entry point to get the export info for an existing volume.     #
+    #         parameters   : context, volume                                                       #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def ensure_export(self, context, volume):
+        """Driver entry point to get the export info for an existing volume."""
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : create_export                                                                       #
+    #         summary      : Driver entry point to get the export info for a new volume.           #
+    #         parameters   : context, volume                                                       #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def create_export(self, context, volume):
+        """Driver entry point to get the export info for a new volume."""
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : remove_export                                                                       #
+    #         summary      : Driver entry point to remove an export for a volume.                  #
+    #         parameters   : context, volume                                                       #
+    #         return-value : none                                                                  #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    def remove_export(self, context, volume):
+        """Driver entry point to remove an export for a volume."""
+        pass
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : initialize_connection                                                               #
+    #         summary      : set HostAffinityGroup on ETERNUS                                      #
+    #         parameters   : volume, connector                                                     #
+    #         return-value : connection info                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def initialize_connection(self, volume, connector):
+        '''
+        Allow connection to connector and return connection info.
+        '''
+        LOG.debug(_('*****initialize_connection,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        info=self.common.initialize_connection(volume, connector)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****initialize_connection,'
+                    'processing time:%s sec') % processing_time)
+
+        return info
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : terminate_connection                                                                #
+    #         summary      : remove HostAffinityGroup on ETERNUS                                   #
+    #         parameters   : volume, connector                                                     #
+    #         return-value :                                                                       #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def terminate_connection(self, volume, connector, **kwargs):
+        '''
+        Disallow connection from connector.
+        '''
+        LOG.debug(_('*****terminate_connection,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        self.common.terminate_connection(volume, connector)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****terminate_connection,'
+                    'processing time:%s sec') % processing_time)
+
+        return
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : get_volume_stats                                                                    #
+    #         summary      : get pool capacity                                                     #
+    #         parameters   : refresh                                                               #
+    #         return-value : self.stats                                                            #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def get_volume_stats(self, refresh=False):
+        '''
+        Get volume stats.
+        If 'refresh' is True, run update the stats first.
+        '''
+        LOG.debug(_('*****get_volume_stats,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+        enter_time = time.time()
+
+        if refresh == True:
+            data                        = self.common.refresh_volume_stats()
+            backend_name                = self.configuration.safe_get('volume_backend_name')
+            data['volume_backend_name'] = backend_name or 'FJDXISCSIDriver'
+            data['storage_protocol']    = 'iSCSI'
+            self._stats                 = data
+        # end of if
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****get_volume_stats,'
+                    'processing time:%s sec') % processing_time)
+
+        return self._stats
+
+    #----------------------------------------------------------------------------------------------#
+    # Method : extend_volume                                                                       #
+    #         summary      : extend volume on ETERNUS                                              #
+    #         parameters   : volume, new_size                                                      #
+    #         return-value :                                                        #
+    #         exceptions   :                                                                       #
+    #----------------------------------------------------------------------------------------------#
+    @lockutils.synchronized('ETERNUS_DX-vol', 'cinder-', True)
+    def extend_volume(self, volume, new_size):
+        '''
+        Extend volume.
+        '''
+        LOG.debug(_('*****extend_volume,Enter method'))
+        processing_time  = 0
+        enter_time       = 0
+        exit_time        = 0
+
+        enter_time = time.time()
+        self.common.extend_volume(volume, new_size)
+
+        exit_time = time.time()
+        processing_time = exit_time-enter_time
+        processing_time = str(processing_time)
+        LOG.debug(_('*****extend_volume,'
+                    'processing time:%s sec') % processing_time)
+
+        return
Index: cinder/volume/drivers/fujitsu/__init__.py
===================================================================
--- /dev/null
+++ cinder/volume/drivers/fujitsu/__init__.py
@@ -0,0 +1 @@
+#Needed
Index: cinder.egg-info/SOURCES.txt
===================================================================
--- cinder.egg-info/SOURCES.txt.orig
+++ cinder.egg-info/SOURCES.txt
@@ -578,6 +578,10 @@ cinder/volume/drivers/emc/emc_smis_commo
 cinder/volume/drivers/emc/emc_smis_fc.py
 cinder/volume/drivers/emc/emc_smis_iscsi.py
 cinder/volume/drivers/emc/emc_vnx_cli.py
+cinder/volume/drivers/fujitsu/__init__.py
+cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_common.py
+cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_fc.py
+cinder/volume/drivers/fujitsu/fujitsu_eternus_dx_iscsi.py
 cinder/volume/drivers/hds/__init__.py
 cinder/volume/drivers/hds/hds.py
 cinder/volume/drivers/hds/hus_backend.py
@@ -723,4 +727,4 @@ tools/lintstack.sh
 tools/with_venv.sh
 tools/config/check_uptodate.sh
 tools/config/generate_sample.sh
-tools/config/oslo.config.generator.rc
\ No newline at end of file
+tools/config/oslo.config.generator.rc
