¡@

OpenStack Study: init.py

OpenStack Index

**** CubicPower OpenStack Study ****

# 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.

"""

Volume driver for IBM Storwize family and SVC storage systems.

Notes:

1. If you specify both a password and a key file, this driver will use the

key file only.

2. When using a key file for authentication, it is up to the user or

system administrator to store the private key in a safe manner.

3. The defaults for creating volumes are "-rsize 2% -autoexpand

-grainsize 256 -warning 0". These can be changed in the configuration

file or by using volume types(recommended only for advanced users).

Limitations:

1. The driver expects CLI output in English, error messages may be in a

localized format.

2. Clones and creating volumes from snapshots, where the source and target

are of different sizes, is not supported.

"""

import math

from oslo.config import cfg

from cinder import context

from cinder import exception

from cinder.openstack.common import excutils

from cinder.openstack.common import log as logging

from cinder.openstack.common import loopingcall

from cinder import units

from cinder import utils

from cinder.volume.drivers.ibm.storwize_svc import helpers as storwize_helpers

from cinder.volume.drivers.san import san

from cinder.volume import volume_types

LOG = logging.getLogger(__name__)

storwize_svc_opts = [

cfg.StrOpt('storwize_svc_volpool_name',

default='volpool',

help='Storage system storage pool for volumes'),

cfg.IntOpt('storwize_svc_vol_rsize',

default=2,

help='Storage system space-efficiency parameter for volumes '

'(percentage)'),

cfg.IntOpt('storwize_svc_vol_warning',

default=0,

help='Storage system threshold for volume capacity warnings '

'(percentage)'),

cfg.BoolOpt('storwize_svc_vol_autoexpand',

default=True,

help='Storage system autoexpand parameter for volumes '

'(True/False)'),

cfg.IntOpt('storwize_svc_vol_grainsize',

default=256,

help='Storage system grain size parameter for volumes '

'(32/64/128/256)'),

cfg.BoolOpt('storwize_svc_vol_compression',

default=False,

help='Storage system compression option for volumes'),

cfg.BoolOpt('storwize_svc_vol_easytier',

default=True,

help='Enable Easy Tier for volumes'),

cfg.IntOpt('storwize_svc_vol_iogrp',

default=0,

help='The I/O group in which to allocate volumes'),

cfg.IntOpt('storwize_svc_flashcopy_timeout',

default=120,

help='Maximum number of seconds to wait for FlashCopy to be '

'prepared. Maximum value is 600 seconds (10 minutes)'),

cfg.StrOpt('storwize_svc_connection_protocol',

default='iSCSI',

help='Connection protocol (iSCSI/FC)'),

cfg.BoolOpt('storwize_svc_iscsi_chap_enabled',

default=True,

help='Configure CHAP authentication for iSCSI connections '

'(Default: Enabled)'),

cfg.BoolOpt('storwize_svc_multipath_enabled',

default=False,

help='Connect with multipath (FC only; iSCSI multipath is '

'controlled by Nova)'),

cfg.BoolOpt('storwize_svc_multihostmap_enabled',

default=True,

help='Allows vdisk to multi host mapping'),

]

CONF = cfg.CONF

CONF.register_opts(storwize_svc_opts)

**** CubicPower OpenStack Study ****

class StorwizeSVCDriver(san.SanDriver):

"""IBM Storwize V7000 and SVC iSCSI/FC volume driver.

Version history:

1.0 - Initial driver

1.1 - FC support, create_cloned_volume, volume type support,

get_volume_stats, minor bug fixes

1.2.0 - Added retype

1.2.1 - Code refactor, improved exception handling

1.2.2 - Fix bug #1274123 (races in host-related functions)

1.2.3 - Fix Fibre Channel connectivity: bug #1279758 (add delim to

lsfabric, clear unused data from connections, ensure matching

WWPNs by comparing lower case

1.2.4 - Fix bug #1278035 (async migration/retype)

1.2.5 - Added support for manage_existing (unmanage is inherited)

"""

VERSION = "1.2.5"

VDISKCOPYOPS_INTERVAL = 600

**** CubicPower OpenStack Study ****

def __init__(self, *args, **kwargs):

super(StorwizeSVCDriver, self).__init__(*args, **kwargs)

self.configuration.append_config_values(storwize_svc_opts)

self._helpers = storwize_helpers.StorwizeHelpers(self._run_ssh)

self._vdiskcopyops = {}

self._vdiskcopyops_loop = None

self._state = {'storage_nodes': {},

'enabled_protocols': set(),

'compression_enabled': False,

'available_iogrps': [],

**** CubicPower OpenStack Study ****

def do_setup(self, ctxt):

"""Check that we have all configuration details from the storage."""

LOG.debug(_('enter: do_setup'))

# Get storage system name, id, and code level

self._state.update(self._helpers.get_system_info())

# Validate that the pool exists

pool = self.configuration.storwize_svc_volpool_name

try:

self._helpers.get_pool_attrs(pool)

except exception.VolumeBackendAPIException:

msg = _('Failed getting details for pool %s') % pool

raise exception.InvalidInput(reason=msg)

# Check if compression is supported

self._state['compression_enabled'] = \

self._helpers.compression_enabled()

# Get the available I/O groups

self._state['available_iogrps'] = \

self._helpers.get_available_io_groups()

# Get the iSCSI and FC names of the Storwize/SVC nodes

self._state['storage_nodes'] = self._helpers.get_node_info()

# Add the iSCSI IP addresses and WWPNs to the storage node info

self._helpers.add_iscsi_ip_addrs(self._state['storage_nodes'])

self._helpers.add_fc_wwpns(self._state['storage_nodes'])

# For each node, check what connection modes it supports. Delete any

# nodes that do not support any types (may be partially configured).

to_delete = []

for k, node in self._state['storage_nodes'].iteritems():

if ((len(node['ipv4']) or len(node['ipv6']))

and len(node['iscsi_name'])):

node['enabled_protocols'].append('iSCSI')

self._state['enabled_protocols'].add('iSCSI')

if len(node['WWPN']):

node['enabled_protocols'].append('FC')

self._state['enabled_protocols'].add('FC')

if not len(node['enabled_protocols']):

to_delete.append(k)

for delkey in to_delete:

del self._state['storage_nodes'][delkey]

# Make sure we have at least one node configured

if not len(self._state['storage_nodes']):

msg = _('do_setup: No configured nodes.')

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

# Build the list of in-progress vdisk copy operations

if ctxt is None:

admin_context = context.get_admin_context()

else:

admin_context = ctxt.elevated()

volumes = self.db.volume_get_all_by_host(admin_context, self.host)

for volume in volumes:

metadata = self.db.volume_admin_metadata_get(admin_context,

volume['id'])

curr_ops = metadata.get('vdiskcopyops', None)

if curr_ops:

ops = [tuple(x.split(':')) for x in curr_ops.split(';')]

self._vdiskcopyops[volume['id']] = ops

# if vdiskcopy exists in database, start the looping call

if len(self._vdiskcopyops) >= 1:

self._vdiskcopyops_loop = loopingcall.LoopingCall(

self._check_volume_copy_ops)

self._vdiskcopyops_loop.start(interval=self.VDISKCOPYOPS_INTERVAL)

LOG.debug(_('leave: do_setup'))

**** CubicPower OpenStack Study ****

def check_for_setup_error(self):

"""Ensure that the flags are set properly."""

LOG.debug(_('enter: check_for_setup_error'))

# Check that we have the system ID information

if self._state['system_name'] is None:

exception_msg = (_('Unable to determine system name'))

raise exception.VolumeBackendAPIException(data=exception_msg)

if self._state['system_id'] is None:

exception_msg = (_('Unable to determine system id'))

raise exception.VolumeBackendAPIException(data=exception_msg)

required_flags = ['san_ip', 'san_ssh_port', 'san_login',

'storwize_svc_volpool_name']

for flag in required_flags:

if not self.configuration.safe_get(flag):

raise exception.InvalidInput(reason=_('%s is not set') % flag)

# Ensure that either password or keyfile were set

if not (self.configuration.san_password or

self.configuration.san_private_key):

raise exception.InvalidInput(

reason=_('Password or SSH private key is required for '

'authentication: set either san_password or '

'san_private_key option'))

# Check that flashcopy_timeout is not more than 10 minutes

flashcopy_timeout = self.configuration.storwize_svc_flashcopy_timeout

if not (flashcopy_timeout > 0 and flashcopy_timeout <= 600):

raise exception.InvalidInput(

reason=_('Illegal value %d specified for '

'storwize_svc_flashcopy_timeout: '

'valid values are between 0 and 600')

% flashcopy_timeout)

opts = self._helpers.build_default_opts(self.configuration)

self._helpers.check_vdisk_opts(self._state, opts)

LOG.debug(_('leave: check_for_setup_error'))

**** CubicPower OpenStack Study ****

def ensure_export(self, ctxt, volume):

"""Check that the volume exists on the storage.

The system does not "export" volumes as a Linux iSCSI target does,

and therefore we just check that the volume exists on the storage.

"""

volume_defined = self._helpers.is_vdisk_defined(volume['name'])

if not volume_defined:

LOG.error(_('ensure_export: Volume %s not found on storage')

% volume['name'])

**** CubicPower OpenStack Study ****

def create_export(self, ctxt, volume):

model_update = None

return model_update

**** CubicPower OpenStack Study ****

def remove_export(self, ctxt, volume):

pass

**** CubicPower OpenStack Study ****

def validate_connector(self, connector):

"""Check connector for at least one enabled protocol (iSCSI/FC)."""

valid = False

if ('iSCSI' in self._state['enabled_protocols'] and

'initiator' in connector):

valid = True

if 'FC' in self._state['enabled_protocols'] and 'wwpns' in connector:

valid = True

if not valid:

msg = (_('The connector does not contain the required '

'information.'))

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

**** CubicPower OpenStack Study ****

def _get_vdisk_params(self, type_id, volume_type=None):

return self._helpers.get_vdisk_params(self.configuration, self._state,

type_id, volume_type=volume_type)

@utils.synchronized('storwize-host', external=True)

**** CubicPower OpenStack Study ****

def initialize_connection(self, volume, connector):

"""Perform the necessary work so that an iSCSI/FC connection can

be made.

To be able to create an iSCSI/FC connection from a given host to a

volume, we must:

1. Translate the given iSCSI name or WWNN to a host name

2. Create new host on the storage system if it does not yet exist

3. Map the volume to the host if it is not already done

4. Return the connection information for relevant nodes (in the

proper I/O group)

"""

LOG.debug(_('enter: initialize_connection: volume %(vol)s with '

'connector %(conn)s') % {'vol': volume, 'conn': connector})

vol_opts = self._get_vdisk_params(volume['volume_type_id'])

volume_name = volume['name']

# Delete irrelevant connection information that later could result

# in unwanted behaviour. For example, if FC is used yet the hosts

# return iSCSI data, the driver will try to create the iSCSI connection

# which can result in a nice error about reaching the per-host maximum

# iSCSI initiator limit.

# First make a copy so we don't mess with a caller's connector.

connector = connector.copy()

if vol_opts['protocol'] == 'FC':

connector.pop('initiator', None)

elif vol_opts['protocol'] == 'iSCSI':

connector.pop('wwnns', None)

connector.pop('wwpns', None)

# Check if a host object is defined for this host name

host_name = self._helpers.get_host_from_connector(connector)

if host_name is None:

# Host does not exist - add a new host to Storwize/SVC

host_name = self._helpers.create_host(connector)

if vol_opts['protocol'] == 'iSCSI':

chap_secret = self._helpers.get_chap_secret_for_host(host_name)

chap_enabled = self.configuration.storwize_svc_iscsi_chap_enabled

if chap_enabled and chap_secret is None:

chap_secret = self._helpers.add_chap_secret_to_host(host_name)

elif not chap_enabled and chap_secret:

LOG.warning(_('CHAP secret exists for host but CHAP is '

'disabled'))

volume_attributes = self._helpers.get_vdisk_attributes(volume_name)

if volume_attributes is None:

msg = (_('initialize_connection: Failed to get attributes'

' for volume %s') % volume_name)

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

multihostmap = self.configuration.storwize_svc_multihostmap_enabled

lun_id = self._helpers.map_vol_to_host(volume_name, host_name,

multihostmap)

try:

preferred_node = volume_attributes['preferred_node_id']

IO_group = volume_attributes['IO_group_id']

except KeyError as e:

LOG.error(_('Did not find expected column name in '

'lsvdisk: %s') % e)

msg = (_('initialize_connection: Missing volume '

'attribute for volume %s') % volume_name)

raise exception.VolumeBackendAPIException(data=msg)

try:

# Get preferred node and other nodes in I/O group

preferred_node_entry = None

io_group_nodes = []

for node in self._state['storage_nodes'].itervalues():

if vol_opts['protocol'] not in node['enabled_protocols']:

continue

if node['id'] == preferred_node:

preferred_node_entry = node

if node['IO_group'] == IO_group:

io_group_nodes.append(node)

if not len(io_group_nodes):

msg = (_('initialize_connection: No node found in '

'I/O group %(gid)s for volume %(vol)s') %

{'gid': IO_group, 'vol': volume_name})

LOG.error(msg)

raise exception.VolumeBackendAPIException(data=msg)

if not preferred_node_entry and not vol_opts['multipath']:

# Get 1st node in I/O group

preferred_node_entry = io_group_nodes[0]

LOG.warn(_('initialize_connection: Did not find a preferred '

'node for volume %s') % volume_name)

properties = {}

properties['target_discovered'] = False

properties['target_lun'] = lun_id

properties['volume_id'] = volume['id']

if vol_opts['protocol'] == 'iSCSI':

type_str = 'iscsi'

if len(preferred_node_entry['ipv4']):

ipaddr = preferred_node_entry['ipv4'][0]

else:

ipaddr = preferred_node_entry['ipv6'][0]

properties['target_portal'] = '%s:%s' % (ipaddr, '3260')

properties['target_iqn'] = preferred_node_entry['iscsi_name']

if chap_secret:

properties['auth_method'] = 'CHAP'

properties['auth_username'] = connector['initiator']

properties['auth_password'] = chap_secret

else:

type_str = 'fibre_channel'

conn_wwpns = self._helpers.get_conn_fc_wwpns(host_name)

if len(conn_wwpns) == 0:

msg = (_('Could not get FC connection information for the '

'host-volume connection. Is the host configured '

'properly for FC connections?'))

LOG.error(msg)

raise exception.VolumeBackendAPIException(data=msg)

if not vol_opts['multipath']:

if preferred_node_entry['WWPN'] in conn_wwpns:

properties['target_wwn'] = preferred_node_entry['WWPN']

else:

properties['target_wwn'] = conn_wwpns[0]

else:

properties['target_wwn'] = conn_wwpns

i_t_map = self._make_initiator_target_map(connector['wwpns'],

conn_wwpns)

properties['initiator_target_map'] = i_t_map

except Exception:

with excutils.save_and_reraise_exception():

self.terminate_connection(volume, connector)

LOG.error(_('initialize_connection: Failed to collect return '

'properties for volume %(vol)s and connector '

'%(conn)s.\n') % {'vol': volume,

'conn': connector})

LOG.debug(_('leave: initialize_connection:\n volume: %(vol)s\n '

'connector %(conn)s\n properties: %(prop)s')

% {'vol': volume, 'conn': connector, 'prop': properties})

return {'driver_volume_type': type_str, 'data': properties, }

**** CubicPower OpenStack Study ****

def _make_initiator_target_map(self, initiator_wwpns, target_wwpns):

"""Build a simplistic all-to-all mapping."""

i_t_map = {}

for i_wwpn in initiator_wwpns:

i_t_map[str(i_wwpn)] = []

for t_wwpn in target_wwpns:

i_t_map[i_wwpn].append(t_wwpn)

return i_t_map

@utils.synchronized('storwize-host', external=True)

**** CubicPower OpenStack Study ****

def terminate_connection(self, volume, connector, **kwargs):

"""Cleanup after an iSCSI connection has been terminated.

When we clean up a terminated connection between a given connector

and volume, we:

1. Translate the given connector to a host name

2. Remove the volume-to-host mapping if it exists

3. Delete the host if it has no more mappings (hosts are created

automatically by this driver when mappings are created)

"""

LOG.debug(_('enter: terminate_connection: volume %(vol)s with '

'connector %(conn)s') % {'vol': volume, 'conn': connector})

vol_name = volume['name']

if 'host' in connector:

host_name = self._helpers.get_host_from_connector(connector)

if host_name is None:

msg = (_('terminate_connection: Failed to get host name from'

' connector.'))

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

if 'wwpns' in connector and host_name:

target_wwpns = self._helpers.get_conn_fc_wwpns(host_name)

init_targ_map = self._make_initiator_target_map(connector['wwpns'],

target_wwpns)

info = {'driver_volume_type': 'fibre_channel',

'data': {'initiator_target_map': init_targ_map}}

self._helpers.unmap_vol_from_host(vol_name, host_name)

LOG.debug(_('leave: terminate_connection: volume %(vol)s with '

'connector %(conn)s') % {'vol': volume, 'conn': connector})

return info

**** CubicPower OpenStack Study ****

def create_volume(self, volume):

opts = self._get_vdisk_params(volume['volume_type_id'])

pool = self.configuration.storwize_svc_volpool_name

return self._helpers.create_vdisk(volume['name'], str(volume['size']),

'gb', pool, opts)

**** CubicPower OpenStack Study ****

def delete_volume(self, volume):

self._helpers.delete_vdisk(volume['name'], False)

**** CubicPower OpenStack Study ****

def create_snapshot(self, snapshot):

ctxt = context.get_admin_context()

try:

source_vol = self.db.volume_get(ctxt, snapshot['volume_id'])

except Exception:

msg = (_('create_snapshot: get source volume failed.'))

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

opts = self._get_vdisk_params(source_vol['volume_type_id'])

self._helpers.create_copy(snapshot['volume_name'], snapshot['name'],

snapshot['volume_id'], self.configuration,

opts, False)

**** CubicPower OpenStack Study ****

def delete_snapshot(self, snapshot):

self._helpers.delete_vdisk(snapshot['name'], False)

**** CubicPower OpenStack Study ****

def create_volume_from_snapshot(self, volume, snapshot):

if volume['size'] != snapshot['volume_size']:

msg = (_('create_volume_from_snapshot: Source and destination '

'size differ.'))

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

opts = self._get_vdisk_params(volume['volume_type_id'])

self._helpers.create_copy(snapshot['name'], volume['name'],

snapshot['id'], self.configuration,

opts, True)

**** CubicPower OpenStack Study ****

def create_cloned_volume(self, tgt_volume, src_volume):

if src_volume['size'] != tgt_volume['size']:

msg = (_('create_cloned_volume: Source and destination '

'size differ.'))

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

opts = self._get_vdisk_params(tgt_volume['volume_type_id'])

self._helpers.create_copy(src_volume['name'], tgt_volume['name'],

src_volume['id'], self.configuration,

opts, True)

**** CubicPower OpenStack Study ****

def extend_volume(self, volume, new_size):

LOG.debug(_('enter: extend_volume: volume %s') % volume['id'])

ret = self._helpers.ensure_vdisk_no_fc_mappings(volume['name'],

allow_snaps=False)

if not ret:

msg = (_('extend_volume: Extending a volume with snapshots is not '

'supported.'))

LOG.error(msg)

raise exception.VolumeDriverException(message=msg)

extend_amt = int(new_size) - volume['size']

self._helpers.extend_vdisk(volume['name'], extend_amt)

LOG.debug(_('leave: extend_volume: volume %s') % volume['id'])

**** CubicPower OpenStack Study ****

def _add_vdisk_copy_op(self, ctxt, volume, new_op):

metadata = self.db.volume_admin_metadata_get(ctxt.elevated(),

volume['id'])

curr_ops = metadata.get('vdiskcopyops', None)

if curr_ops:

curr_ops_list = [tuple(x.split(':')) for x in curr_ops.split(';')]

new_ops_list = curr_ops_list.append(new_op)

else:

new_ops_list = [new_op]

new_ops_str = ';'.join([':'.join(x) for x in new_ops_list])

self.db.volume_admin_metadata_update(ctxt.elevated(), volume['id'],

{'vdiskcopyops': new_ops_str},

False)

if volume['id'] in self._vdiskcopyops:

self._vdiskcopyops[volume['id']].append(new_op)

else:

self._vdiskcopyops[volume['id']] = [new_op]

# We added the first copy operation, so start the looping call

if len(self._vdiskcopyops) == 1:

self._vdiskcopyops_loop = loopingcall.LoopingCall(

self._check_volume_copy_ops)

self._vdiskcopyops_loop.start(interval=self.VDISKCOPYOPS_INTERVAL)

**** CubicPower OpenStack Study ****

def _rm_vdisk_copy_op(self, ctxt, volume, orig_copy_id, new_copy_id):

try:

self._vdiskcopyops[volume['id']].remove((orig_copy_id,

new_copy_id))

if not len(self._vdiskcopyops[volume['id']]):

del self._vdiskcopyops[volume['id']]

if not len(self._vdiskcopyops):

self._vdiskcopyops_loop.stop()

self._vdiskcopyops_loop = None

except IndexError:

msg = (_('_rm_vdisk_copy_op: Volume %s does not have any '

'registered vdisk copy operations.') % volume['id'])

LOG.error(msg)

return

except ValueError:

msg = (_('_rm_vdisk_copy_op: Volume %(vol)s does not have the '

'specified vdisk copy operation: orig=%(orig)s '

'new=%(new)s.')

% {'vol': volume['id'], 'orig': orig_copy_id,

'new': new_copy_id})

LOG.error(msg)

return

metadata = self.db.volume_admin_metadata_get(ctxt.elevated(),

volume['id'])

curr_ops = metadata.get('vdiskcopyops', None)

if not curr_ops:

msg = (_('_rm_vdisk_copy_op: Volume metadata %s does not have any '

'registered vdisk copy operations.') % volume['id'])

LOG.error(msg)

return

curr_ops_list = [tuple(x.split(':')) for x in curr_ops.split(';')]

try:

curr_ops_list.remove((orig_copy_id, new_copy_id))

except ValueError:

msg = (_('_rm_vdisk_copy_op: Volume %(vol)s metadata does not '

'have the specified vdisk copy operation: orig=%(orig)s '

'new=%(new)s.')

% {'vol': volume['id'], 'orig': orig_copy_id,

'new': new_copy_id})

LOG.error(msg)

return

if len(curr_ops_list):

new_ops_str = ';'.join([':'.join(x) for x in curr_ops_list])

self.db.volume_admin_metadata_update(ctxt.elevated(), volume['id'],

{'vdiskcopyops': new_ops_str},

False)

else:

self.db.volume_admin_metadata_delete(ctxt.elevated(), volume['id'],

'vdiskcopyops')

**** CubicPower OpenStack Study ****

def _check_volume_copy_ops(self):

LOG.debug(_("enter: update volume copy status"))

ctxt = context.get_admin_context()

copy_items = self._vdiskcopyops.items()

for vol_id, copy_ops in copy_items:

volume = self.db.volume_get(ctxt, vol_id)

for copy_op in copy_ops:

try:

synced = self._helpers.is_vdisk_copy_synced(volume['name'],

copy_op[1])

except Exception:

msg = (_('_check_volume_copy_ops: Volume %(vol)s does not '

'have the specified vdisk copy operation: '

'orig=%(orig)s new=%(new)s.')

% {'vol': volume['id'], 'orig': copy_op[0],

self._helpers.rm_vdisk_copy(volume['name'], copy_op[0])

self._rm_vdisk_copy_op(ctxt, volume, copy_op[0],

copy_op[1])

LOG.debug(_("exit: update volume copy status"))

**** CubicPower OpenStack Study ****

def migrate_volume(self, ctxt, volume, host):

"""Migrate directly if source and dest are managed by same storage.

We create a new vdisk copy in the desired pool, and add the original

vdisk copy to the admin_metadata of the volume to be deleted. The

deletion will occur using a periodic task once the new copy is synced.

:param ctxt: Context

:param volume: A dictionary describing the volume to migrate

:param host: A dictionary describing the host to migrate to, where

host['host'] is its name, and host['capabilities'] is a

dictionary of its reported capabilities.

"""

LOG.debug(_('enter: migrate_volume: id=%(id)s, host=%(host)s') %

{'id': volume['id'], 'host': host['host']})

false_ret = (False, None)

dest_pool = self._helpers.can_migrate_to_host(host, self._state)

if dest_pool is None:

return false_ret

ctxt = context.get_admin_context()

if volume['volume_type_id'] is not None:

volume_type_id = volume['volume_type_id']

vol_type = volume_types.get_volume_type(ctxt, volume_type_id)

else:

vol_type = None

new_op = self._helpers.add_vdisk_copy(volume['name'], dest_pool,

vol_type, self._state,

self.configuration)

self._add_vdisk_copy_op(ctxt, volume, new_op)

LOG.debug(_('leave: migrate_volume: id=%(id)s, host=%(host)s') %

{'id': volume['id'], 'host': host['host']})

return (True, None)

**** CubicPower OpenStack Study ****

def retype(self, ctxt, volume, new_type, diff, host):

"""Convert the volume to be of the new type.

Returns a boolean indicating whether the retype occurred.

:param ctxt: Context

:param volume: A dictionary describing the volume to migrate

:param new_type: A dictionary describing the volume type to convert to

:param diff: A dictionary with the difference between the two types

:param host: A dictionary describing the host to migrate to, where

host['host'] is its name, and host['capabilities'] is a

dictionary of its reported capabilities.

"""

LOG.debug(_('enter: retype: id=%(id)s, new_type=%(new_type)s,'

'diff=%(diff)s, host=%(host)s') % {'id': volume['id'],

'new_type': new_type,

'diff': diff,

'host': host})

ignore_keys = ['protocol', 'multipath']

no_copy_keys = ['warning', 'autoexpand', 'easytier']

copy_keys = ['rsize', 'grainsize', 'compression']

all_keys = ignore_keys + no_copy_keys + copy_keys

old_opts = self._get_vdisk_params(volume['volume_type_id'])

new_opts = self._get_vdisk_params(new_type['id'],

volume_type=new_type)

vdisk_changes = []

need_copy = False

for key in all_keys:

if old_opts[key] != new_opts[key]:

if key in copy_keys:

need_copy = True

break

elif key in no_copy_keys:

vdisk_changes.append(key)

dest_location = host['capabilities'].get('location_info')

if self._stats['location_info'] != dest_location:

need_copy = True

if need_copy:

dest_pool = self._helpers.can_migrate_to_host(host, self._state)

if dest_pool is None:

return False

if old_opts['iogrp'] != new_opts['iogrp']:

self._helpers.change_vdisk_iogrp(volume['name'], self._state,

(new_opts['iogrp'],

old_opts['iogrp']))

new_op = self._helpers.add_vdisk_copy(volume['name'], dest_pool,

new_type, self._state,

self.configuration)

self._add_vdisk_copy_op(ctxt, volume, new_op)

else:

if old_opts['iogrp'] != new_opts['iogrp']:

self._helpers.change_vdisk_iogrp(volume['name'], self._state,

(new_opts['iogrp'],

old_opts['iogrp']))

self._helpers.change_vdisk_options(volume['name'], vdisk_changes,

new_opts, self._state)

LOG.debug(_('exit: retype: ild=%(id)s, new_type=%(new_type)s,'

'diff=%(diff)s, host=%(host)s') % {'id': volume['id'],

'new_type': new_type,

'diff': diff,

'host': host['host']})

return True

**** CubicPower OpenStack Study ****

def manage_existing(self, volume, ref):

"""Manages an existing vdisk.

Renames the vdisk to match the expected name for the volume.

Error checking done by manage_existing_get_size is not repeated -

if we got here then we have a vdisk that isn't in use (or we don't

care if it is in use.

"""

vdisk = self._helpers.vdisk_by_uid(ref['vdisk_UID'])

if vdisk is None:

reason = _('No vdisk with the specified vdisk_UID.')

raise exception.ManageExistingInvalidReference(existing_ref=ref,

reason=reason)

self._helpers.rename_vdisk(vdisk['name'], volume['name'])

**** CubicPower OpenStack Study ****

def manage_existing_get_size(self, volume, ref):

"""Return size of an existing LV for manage_existing.

existing_ref is a dictionary of the form:

{'vdisk_UID': }

Optional elements are:

'manage_if_in_use': True/False (default is False)

If set to True, a volume will be managed even if it is currently

attached to a host system.

"""

# Check that the reference is valid

if 'vdisk_UID' not in ref:

reason = _('Reference must contain vdisk_UID element.')

raise exception.ManageExistingInvalidReference(existing_ref=ref,

reason=reason)

# Check for existence of the vdisk

vdisk = self._helpers.vdisk_by_uid(ref['vdisk_UID'])

if vdisk is None:

reason = _('No vdisk with the specified vdisk_UID.')

raise exception.ManageExistingInvalidReference(existing_ref=ref,

reason=reason)

# Check if the disk is in use, if we need to.

manage_if_in_use = ref.get('manage_if_in_use', False)

if (not manage_if_in_use and

self._helpers.is_vdisk_in_use(vdisk['name'])):

reason = _('The specified vdisk is mapped to a host.')

raise exception.ManageExistingInvalidReference(existing_ref=ref,

reason=reason)

return int(math.ceil(float(vdisk['capacity']) / units.GiB))

**** CubicPower OpenStack Study ****

def get_volume_stats(self, refresh=False):

"""Get volume stats.

If we haven't gotten stats yet or 'refresh' is True,

run update the stats first.

"""

if not self._stats or refresh:

self._update_volume_stats()

return self._stats

**** CubicPower OpenStack Study ****

def _update_volume_stats(self):

"""Retrieve stats info from volume group."""

LOG.debug(_("Updating volume stats"))

data = {}

data['vendor_name'] = 'IBM'

data['driver_version'] = self.VERSION

data['storage_protocol'] = list(self._state['enabled_protocols'])

data['total_capacity_gb'] = 0 # To be overwritten

data['free_capacity_gb'] = 0 # To be overwritten

data['reserved_percentage'] = self.configuration.reserved_percentage

data['QoS_support'] = False

pool = self.configuration.storwize_svc_volpool_name

backend_name = self.configuration.safe_get('volume_backend_name')

if not backend_name:

backend_name = '%s_%s' % (self._state['system_name'], pool)

data['volume_backend_name'] = backend_name

attributes = self._helpers.get_pool_attrs(pool)

if not attributes:

LOG.error(_('Could not get pool data from the storage'))

exception_message = (_('_update_volume_stats: '

'Could not get storage pool data'))

raise exception.VolumeBackendAPIException(data=exception_message)

data['total_capacity_gb'] = (float(attributes['capacity']) /

units.GiB)

data['free_capacity_gb'] = (float(attributes['free_capacity']) /

units.GiB)

data['easytier_support'] = attributes['easy_tier'] in ['on', 'auto']

data['compression_support'] = self._state['compression_enabled']

data['location_info'] = ('StorwizeSVCDriver:%(sys_id)s:%(pool)s' %

{'sys_id': self._state['system_id'],

'pool': pool})

self._stats = data

OpenStack Study: __init__.py

OpenStack Index

OpenStack Study: init.py