def setUp(self): super(ShareRpcAPITestCase, self).setUp() self.context = context.get_admin_context() share = db_utils.create_share( availability_zone=CONF.storage_availability_zone, status=constants.STATUS_AVAILABLE) snapshot = db_utils.create_snapshot(share_id=share['id']) share_replica = db_utils.create_share_replica( id='fake_replica', share_id='fake_share_id', host='fake_host', ) share_server = db_utils.create_share_server() share_group = {'id': 'fake_share_group_id', 'host': 'fake_host'} share_group_snapshot = {'id': 'fake_share_group_id'} host = 'fake_host' self.fake_share = jsonutils.to_primitive(share) # mock out the getattr on the share db model object since jsonutils # doesn't know about those extra attributes to pull in self.fake_share['instance'] = jsonutils.to_primitive(share.instance) self.fake_share_replica = jsonutils.to_primitive(share_replica) self.fake_snapshot = jsonutils.to_primitive(snapshot) self.fake_snapshot['share_instance'] = jsonutils.to_primitive( snapshot.instance) self.fake_share_server = jsonutils.to_primitive(share_server) self.fake_share_group = jsonutils.to_primitive(share_group) self.fake_share_group_snapshot = jsonutils.to_primitive( share_group_snapshot) self.fake_host = jsonutils.to_primitive(host) self.ctxt = context.RequestContext('fake_user', 'fake_project') self.rpcapi = share_rpcapi.ShareAPI()
def manage_share(self, context, share_id, driver_options, request_spec, filter_properties=None): """Ensure that the host exists and can accept the share.""" def _manage_share_set_error(self, context, ex, request_spec): # NOTE(haixin) if failed to scheduler backend for manage share, # and we do not commit quota usages here, so we should set size 0 # because we don't know the real size of the size, and we will # skip quota cuts when unmanage share with manage_error status. self._set_share_state_and_notify('manage_share', { 'status': constants.STATUS_MANAGE_ERROR, 'size': 0 }, context, ex, request_spec) share_ref = db.share_get(context, share_id) try: self.driver.host_passes_filters(context, share_ref['host'], request_spec, filter_properties) except Exception as ex: with excutils.save_and_reraise_exception(): _manage_share_set_error(self, context, ex, request_spec) else: share_rpcapi.ShareAPI().manage_share(context, share_ref, driver_options)
def revert_access_rules(self, share_instances, share_server, dest_host=None): shares_instance_ids = [] for share_instance in share_instances: # Cast all rules to 'queued_to_apply' so that they can be # re-applied. shares_instance_ids.append(share_instance['id']) updates = {'state': constants.ACCESS_STATE_QUEUED_TO_APPLY} self.access_helper.get_and_update_share_instance_access_rules( self.context, updates=updates, share_instance_id=share_instance['id']) if dest_host: rpcapi = share_rpcapi.ShareAPI() rpcapi.update_access_for_instances(self.context, dest_host, shares_instance_ids, share_server) else: for share_instance in share_instances: self.access_helper.update_access_rules( self.context, share_instance['id'], share_server=share_server) for share_instance in share_instances: utils.wait_for_access_update( self.context, self.db, share_instance, self.migration_wait_access_rules_timeout)
def manage_share(self, context, share_id, driver_options, request_spec, filter_properties=None): """Ensure that the host exists and can accept the share.""" def _manage_share_set_error(self, context, ex, request_spec): # NOTE(nidhimittalhada): set size as 1 because design expects size # to be set, it also will allow us to handle delete/unmanage # operations properly with this errored share according to quotas. self._set_share_state_and_notify('manage_share', { 'status': constants.STATUS_MANAGE_ERROR, 'size': 1 }, context, ex, request_spec) share_ref = db.share_get(context, share_id) try: self.driver.host_passes_filters(context, share_ref['host'], request_spec, filter_properties) except Exception as ex: with excutils.save_and_reraise_exception(): _manage_share_set_error(self, context, ex, request_spec) else: share_rpcapi.ShareAPI().manage_share(context, share_ref, driver_options)
def migrate_share_to_host(self, context, share_id, host, force_host_copy, request_spec, filter_properties=None): """Ensure that the host exists and can accept the share.""" def _migrate_share_set_error(self, context, ex, request_spec): self._set_share_state_and_notify( 'migrate_share_to_host', {'task_state': constants.STATUS_TASK_STATE_MIGRATION_ERROR}, context, ex, request_spec) try: tgt_host = self.driver.host_passes_filters(context, host, request_spec, filter_properties) except exception.NoValidHost as ex: _migrate_share_set_error(self, context, ex, request_spec) except Exception as ex: with excutils.save_and_reraise_exception(): _migrate_share_set_error(self, context, ex, request_spec) else: share_ref = db.share_get(context, share_id) try: share_rpcapi.ShareAPI().migrate_share(context, share_ref, tgt_host, force_host_copy) except Exception as ex: with excutils.save_and_reraise_exception(): _migrate_share_set_error(self, context, ex, request_spec)
def extend_share(self, context, share_id, new_size, reservations, request_spec=None, filter_properties=None): def _extend_share_set_error(self, context, ex, request_spec): share_state = {'status': constants.STATUS_AVAILABLE} self._set_share_state_and_notify('extend_share', share_state, context, ex, request_spec) share = db.share_get(context, share_id) try: target_host = self.driver.host_passes_filters( context, share['host'], request_spec, filter_properties) target_host.consume_from_share( {'size': int(new_size) - share['size']}) share_rpcapi.ShareAPI().extend_share(context, share, new_size, reservations) except exception.NoValidHost as ex: quota.QUOTAS.rollback(context, reservations, project_id=share['project_id'], user_id=share['user_id'], share_type_id=share['share_type_id']) _extend_share_set_error(self, context, ex, request_spec) self.message_api.create(context, message_field.Action.EXTEND, share['project_id'], resource_type=message_field.Resource.SHARE, resource_id=share['id'], exception=ex)
def setUp(self): super(ShareRpcAPITestCase, self).setUp() self.context = context.get_admin_context() share = db_utils.create_share( availability_zone=CONF.storage_availability_zone, status=constants.STATUS_AVAILABLE) access = db_utils.create_access(share_id=share['id']) snapshot = db_utils.create_snapshot(share_id=share['id']) share_replica = db_utils.create_share_replica( id='fake_replica', share_id='fake_share_id', ) share_server = db_utils.create_share_server() cg = {'id': 'fake_cg_id', 'host': 'fake_host'} cgsnapshot = {'id': 'fake_cg_id'} host = {'host': 'fake_host', 'capabilities': 1} self.fake_share = jsonutils.to_primitive(share) self.fake_share_replica = jsonutils.to_primitive(share_replica) self.fake_access = jsonutils.to_primitive(access) self.fake_snapshot = jsonutils.to_primitive(snapshot) self.fake_share_server = jsonutils.to_primitive(share_server) self.fake_cg = jsonutils.to_primitive(cg) self.fake_cgsnapshot = jsonutils.to_primitive(cgsnapshot) self.fake_host = jsonutils.to_primitive(host) self.ctxt = context.RequestContext('fake_user', 'fake_project') self.rpcapi = share_rpcapi.ShareAPI()
def __init__(self, context, db, share): self.db = db self.share = share self.context = context self.share_rpc = share_rpc.ShareAPI() self.wait_access_rules_timeout = ( CONF.data_access_wait_access_rules_timeout)
def __init__(self, context, db, share): self.db = db self.share = share self.context = context self.share_rpc = share_rpc.ShareAPI() self.access_helper = access_manager.ShareInstanceAccess(self.db, None) self.wait_access_rules_timeout = ( CONF.data_access_wait_access_rules_timeout)
def migration_start(self, context, ignore_list, share_id, share_instance_id, dest_share_instance_id, connection_info_src, connection_info_dest): LOG.debug( "Received request to migrate share content from share instance " "%(instance_id)s to instance %(dest_instance_id)s.", { 'instance_id': share_instance_id, 'dest_instance_id': dest_share_instance_id }) share_ref = self.db.share_get(context, share_id) share_instance_ref = self.db.share_instance_get(context, share_instance_id, with_share_data=True) share_rpcapi = share_rpc.ShareAPI() mount_path = CONF.mount_tmp_location try: copy = data_utils.Copy( os.path.join(mount_path, share_instance_id), os.path.join(mount_path, dest_share_instance_id), ignore_list, CONF.check_hash) self._copy_share_data(context, copy, share_ref, share_instance_id, dest_share_instance_id, connection_info_src, connection_info_dest) except exception.ShareDataCopyCancelled: share_rpcapi.migration_complete(context, share_instance_ref, dest_share_instance_id) return except Exception: self.db.share_update( context, share_id, {'task_state': constants.TASK_STATE_DATA_COPYING_ERROR}) msg = _("Failed to copy contents from instance %(src)s to " "instance %(dest)s.") % { 'src': share_instance_id, 'dest': dest_share_instance_id } LOG.exception(msg) share_rpcapi.migration_complete(context, share_instance_ref, dest_share_instance_id) raise exception.ShareDataCopyFailed(reason=msg) finally: self.busy_tasks_shares.pop(share_id, None) LOG.info( "Completed copy operation of migrating share content from share " "instance %(instance_id)s to instance %(dest_instance_id)s.", { 'instance_id': share_instance_id, 'dest_instance_id': dest_share_instance_id })
def migrate_share_to_host(self, context, share_id, host, force_host_assisted_migration, preserve_metadata, writable, nondisruptive, preserve_snapshots, new_share_network_id, new_share_type_id, request_spec, filter_properties=None): """Ensure that the host exists and can accept the share.""" share_ref = db.share_get(context, share_id) def _migrate_share_set_error(self, context, ex, request_spec): instance = next((x for x in share_ref.instances if x['status'] == constants.STATUS_MIGRATING), None) if instance: db.share_instance_update( context, instance['id'], {'status': constants.STATUS_AVAILABLE}) self._set_share_state_and_notify( 'migrate_share_to_host', {'task_state': constants.TASK_STATE_MIGRATION_ERROR}, context, ex, request_spec) try: tgt_host = self.driver.host_passes_filters(context, host, request_spec, filter_properties) except Exception as ex: with excutils.save_and_reraise_exception(): _migrate_share_set_error(self, context, ex, request_spec) else: try: share_rpcapi.ShareAPI().migration_start( context, share_ref, tgt_host.host, force_host_assisted_migration, preserve_metadata, writable, nondisruptive, preserve_snapshots, new_share_network_id, new_share_type_id) except Exception as ex: with excutils.save_and_reraise_exception(): _migrate_share_set_error(self, context, ex, request_spec)
def manage_share(self, context, share_id, driver_options, request_spec, filter_properties=None): """Ensure that the host exists and can accept the share.""" def _manage_share_set_error(self, context, ex, request_spec): self._set_share_state_and_notify( 'manage_share', {'status': constants.STATUS_MANAGE_ERROR}, context, ex, request_spec) share_ref = db.share_get(context, share_id) try: self.driver.host_passes_filters(context, share_ref['host'], request_spec, filter_properties) except Exception as ex: with excutils.save_and_reraise_exception(): _manage_share_set_error(self, context, ex, request_spec) else: share_rpcapi.ShareAPI().manage_share(context, share_ref, driver_options)
def setUp(self): super(ShareRpcAPITestCase, self).setUp() self.context = context.get_admin_context() shr = {} shr['host'] = 'fake_host' shr['availability_zone'] = CONF.storage_availability_zone shr['status'] = "available" share = db.share_create(self.context, shr) acs = {} acs['access_type'] = "ip" acs['access_to'] = "123.123.123.123" acs['share_id'] = share['id'] access = db.share_access_create(self.context, acs) snap = {} snap['share_id'] = share['id'] snapshot = db.share_snapshot_create(self.context, snap) server = {'id': 'fake_share_server_id', 'host': 'fake_host'} share_server = db.share_server_create(self.context, server) self.fake_share = jsonutils.to_primitive(share) self.fake_access = jsonutils.to_primitive(access) self.fake_snapshot = jsonutils.to_primitive(snapshot) self.fake_share_server = jsonutils.to_primitive(share_server) self.ctxt = context.RequestContext('fake_user', 'fake_project') self.rpcapi = share_rpcapi.ShareAPI()
def __init__(self): self.host_manager = importutils.import_object( CONF.scheduler_host_manager) self.share_rpcapi = share_rpcapi.ShareAPI()
def __init__(self, db_driver=None): self.scheduler_rpcapi = scheduler_rpcapi.SchedulerAPI() self.share_rpcapi = share_rpcapi.ShareAPI() super(API, self).__init__(db_driver)
def __init__(self): super(ShareNetworkController, self).__init__() self.share_rpcapi = share_rpcapi.ShareAPI()
def request_service_capabilities(self, context): share_rpcapi.ShareAPI().publish_service_capabilities(context)