def execute(self, context, volume_ref, manage_existing_ref): volume_id = volume_ref.id if not self.driver.initialized: driver_name = self.driver.__class__.__name__ LOG.error( _LE("Unable to manage existing volume. " "Volume driver %s not initialized.") % driver_name) flow_common.error_out_volume(context, self.db, volume_id, reason=_("Volume driver %s " "not initialized.") % driver_name) raise exception.DriverNotInitialized() size = self.driver.manage_existing_get_size(volume_ref, manage_existing_ref) return { 'size': size, 'volume_type_id': volume_ref.volume_type_id, 'volume_properties': volume_ref, 'volume_spec': { 'status': volume_ref.status, 'volume_name': volume_ref.name, 'volume_id': volume_ref.id } }
def execute(self, context, volume_ref, volume_spec): volume_spec = dict(volume_spec) volume_id = volume_spec.pop('volume_id', None) if not volume_id: volume_id = volume_ref['id'] # we can't do anything if the driver didn't init if not self.driver.initialized: driver_name = self.driver.__class__.__name__ LOG.exception( _LE("Unable to create volume. " "Volume driver %s not initialized"), driver_name) raise exception.DriverNotInitialized() create_type = volume_spec.pop('type', None) LOG.info( _LI("Volume %(volume_id)s: being created as %(create_type)s " "with specification: %(volume_spec)s"), { 'volume_spec': volume_spec, 'volume_id': volume_id, 'create_type': create_type }) if create_type == 'raw': model_update = self._create_raw_volume(volume_ref=volume_ref, **volume_spec) elif create_type == 'snap': model_update = self._create_from_snapshot(context, volume_ref=volume_ref, **volume_spec) elif create_type == 'source_vol': model_update = self._create_from_source_volume( context, volume_ref=volume_ref, **volume_spec) elif create_type == 'source_replica': model_update = self._create_from_source_replica( context, volume_ref=volume_ref, **volume_spec) elif create_type == 'image': model_update = self._create_from_image(context, volume_ref=volume_ref, **volume_spec) else: raise exception.VolumeTypeNotFound(volume_type_id=create_type) # Persist any model information provided on creation. try: if model_update: volume_ref = self.db.volume_update(context, volume_ref['id'], model_update) except exception.CinderException: # If somehow the update failed we want to ensure that the # failure is logged (but not try rescheduling since the volume at # this point has been created). LOG.exception( _LE("Failed updating model of volume %(volume_id)s " "with creation provided model %(model)s"), { 'volume_id': volume_id, 'model': model_update }) raise return volume_ref
def execute(self, context, volume, manage_existing_ref): driver_name = self.driver.__class__.__name__ if not self.driver.initialized: LOG.error(_LE("Unable to manage existing volume. " "Volume driver %s not initialized.") % driver_name) flow_common.error_out(volume, _("Volume driver %s not " "initialized.") % driver_name, status='error_managing') raise exception.DriverNotInitialized() size = 0 try: size = self.driver.manage_existing_get_size(volume, manage_existing_ref) except Exception: with excutils.save_and_reraise_exception(): reason = _("Volume driver %s get exception.") % driver_name flow_common.error_out(volume, reason, status='error_managing') return {'size': size, 'volume_type_id': volume.volume_type_id, 'volume_properties': volume, 'volume_spec': {'status': volume.status, 'volume_name': volume.name, 'volume_id': volume.id}}
def execute(self, context, volume, volume_spec): volume_spec = dict(volume_spec) volume_id = volume_spec.pop('volume_id', None) if not volume_id: volume_id = volume.id # we can't do anything if the driver didn't init if not self.driver.initialized: driver_name = self.driver.__class__.__name__ LOG.error(_LE("Unable to create volume. " "Volume driver %s not initialized"), driver_name) raise exception.DriverNotInitialized() # NOTE(xyang): Populate consistencygroup_id and consistencygroup # fields before passing to the driver. This is to support backward # compatibility of consistencygroup. if volume.group_id: volume.consistencygroup_id = volume.group_id cg = consistencygroup.ConsistencyGroup() cg.from_group(volume.group) volume.consistencygroup = cg create_type = volume_spec.pop('type', None) LOG.info(_LI("Volume %(volume_id)s: being created as %(create_type)s " "with specification: %(volume_spec)s"), {'volume_spec': volume_spec, 'volume_id': volume_id, 'create_type': create_type}) if create_type == 'raw': model_update = self._create_raw_volume(volume, **volume_spec) elif create_type == 'snap': model_update = self._create_from_snapshot(context, volume, **volume_spec) elif create_type == 'source_vol': model_update = self._create_from_source_volume( context, volume, **volume_spec) elif create_type == 'source_replica': model_update = self._create_from_source_replica( context, volume, **volume_spec) elif create_type == 'image': model_update = self._create_from_image(context, volume, **volume_spec) else: raise exception.VolumeTypeNotFound(volume_type_id=create_type) # Persist any model information provided on creation. try: if model_update: with volume.obj_as_admin(): volume.update(model_update) volume.save() except exception.CinderException: # If somehow the update failed we want to ensure that the # failure is logged (but not try rescheduling since the volume at # this point has been created). LOG.exception(_LE("Failed updating model of volume %(volume_id)s " "with creation provided model %(model)s"), {'volume_id': volume_id, 'model': model_update}) raise
class MessageFieldTest(test.TestCase): @ddt.data({ 'id': '001', 'content': 'schedule allocate volume' }, { 'id': '002', 'content': 'attach volume' }, { 'id': 'invalid', 'content': None }) @ddt.unpack def test_translate_action(self, id, content): result = message_field.translate_action(id) if content is None: content = 'unknown action' self.assertEqual(content, result) @ddt.data({ 'id': '001', 'content': 'An unknown error occurred.' }, { 'id': '002', 'content': 'Driver is not initialized at present.' }, { 'id': 'invalid', 'content': None }) @ddt.unpack def test_translate_detail(self, id, content): result = message_field.translate_detail(id) if content is None: content = 'An unknown error occurred.' self.assertEqual(content, result) @ddt.data( { 'exception': exception.DriverNotInitialized(), 'detail': '', 'expected': '002' }, { 'exception': exception.CinderException(), 'detail': '', 'expected': '001' }, { 'exception': exception.CinderException(), 'detail': message_field.Detail.QUOTA_EXCEED, 'expected': '007' }, { 'exception': '', 'detail': message_field.Detail.QUOTA_EXCEED, 'expected': '007' }) @ddt.unpack def translate_detail_id(self, exception, detail, expected): result = message_field.translate_detail_id(exception, detail) self.assertEqual(expected, result)
def execute(self, context, volume_ref, volume_spec): volume_spec = dict(volume_spec) volume_id = volume_spec.pop('volume_id', None) # we can't do anything if the driver didn't init if not self.driver.initialized: driver_name = self.driver.__class__.__name__ LOG.error( _("Unable to create volume. " "Volume driver %s not initialized") % driver_name) # NOTE(flaper87): Set the error status before # raising any exception. self.db.volume_update(context, volume_id, dict(status='error')) raise exception.DriverNotInitialized() create_type = volume_spec.pop('type', None) create_functor = self._create_func_mapping.get(create_type) if not create_functor: raise exception.VolumeTypeNotFound(volume_type_id=create_type) if not volume_id: volume_id = volume_ref['id'] LOG.info( _("Volume %(volume_id)s: being created using %(functor)s " "with specification: %(volume_spec)s") % { 'volume_spec': volume_spec, 'volume_id': volume_id, 'functor': common.make_pretty_name(create_functor) }) # Call the given functor to make the volume. model_update = create_functor(context, volume_ref=volume_ref, **volume_spec) # Persist any model information provided on creation. try: if model_update: volume_ref = self.db.volume_update(context, volume_ref['id'], model_update) except exception.CinderException as ex: # If somehow the update failed we want to ensure that the # failure is logged (but not try rescheduling since the volume at # this point has been created). if model_update: LOG.exception( _("Failed updating model of volume %(volume_id)s" " with creation provided model %(model)s") % { 'volume_id': volume_id, 'model': model_update }) raise exception.ExportFailure(reason=ex) return volume_ref
def _login(self): client = self._create_client() try: if self.configuration.hpelefthand_debug: client.debug_rest(True) client.login(self.configuration.hpelefthand_username, self.configuration.hpelefthand_password) cluster_info = client.getClusterByName( self.configuration.hpelefthand_clustername) self.cluster_id = cluster_info['id'] virtual_ips = cluster_info['virtualIPAddresses'] self.cluster_vip = virtual_ips[0]['ipV4Address'] return client except hpeexceptions.HTTPNotFound: raise exception.DriverNotInitialized( _('LeftHand cluster not found')) except Exception as ex: raise exception.DriverNotInitialized(ex)
def require_driver_initialized(driver): """Verifies if `driver` is initialized If the driver is not initialized, an exception will be raised. :params driver: The driver instance. :raises: `exception.DriverNotInitialized` """ # we can't do anything if the driver didn't init if not driver.initialized: driver_name = driver.__class__.__name__ LOG.error(_("Volume driver %s not initialized") % driver_name) raise exception.DriverNotInitialized()
def do_setup(self, context): """Set up LeftHand client.""" try: self.client = client.HPLeftHandClient( self.configuration.hplefthand_api_url) self.client.login(self.configuration.hplefthand_username, self.configuration.hplefthand_password) if self.configuration.hplefthand_debug: self.client.debug_rest(True) cluster_info = self.client.getClusterByName( self.configuration.hplefthand_clustername) self.cluster_id = cluster_info['id'] virtual_ips = cluster_info['virtualIPAddresses'] self.cluster_vip = virtual_ips[0]['ipV4Address'] self._update_backend_status() except hpexceptions.HTTPNotFound: raise exception.DriverNotInitialized( _('LeftHand cluster not found')) except Exception as ex: raise exception.DriverNotInitialized(ex)
def execute(self, context, snapshot_ref, manage_existing_ref): if not self.driver.initialized: driver_name = ( self.driver.configuration.safe_get('volume_backend_name')) LOG.error( _LE("Unable to manage existing snapshot. " "Volume driver %s not initialized."), driver_name) flow_common.error_out(snapshot_ref, reason=_("Volume driver %s " "not initialized.") % driver_name) raise exception.DriverNotInitialized() size = self.driver.manage_existing_snapshot_get_size( snapshot=snapshot_ref, existing_ref=manage_existing_ref) return {'size': size, 'snapshot_properties': snapshot_ref}
def wrapper(self, *args, **kwargs): # we can't do anything if the driver didn't init if not self.driver.initialized: driver_name = self.driver.__class__.__name__ raise exception.DriverNotInitialized(driver=driver_name) return func(self, *args, **kwargs)