def test_migrate_volume_as_non_admin(self):
expected_status = 403
host = 'test2'
ctx = context.RequestContext('fake', 'fake')
volume = self._migrate_volume_prep()
self._migrate_volume_exec(ctx, volume, host, expected_status)
def setUp(self):
super(PolicyFileTestCase, self).setUp()
# since is_admin is defined by policy, create context before reset
self.context = context.RequestContext('fake', 'fake')
policy.reset()
self.target = {}
def test_delete_snapshot_online_2(self):
"""Delete the middle snapshot."""
(mox, drv) = self._mox, self._driver
volume = self._simple_volume()
volume['status'] = 'in-use'
ctxt = context.RequestContext('fake_user', 'fake_project')
snap_ref = {
'name': 'test snap to delete (online)',
'volume_id': self.VOLUME_UUID,
'volume': volume,
'id': self.SNAP_UUID,
'context': ctxt
}
hashed = drv._get_hash_str(self.TEST_EXPORT1)
volume_file = 'volume-%s' % self.VOLUME_UUID
volume_path = '%s/%s/%s' % (self.TEST_MNT_POINT_BASE, hashed,
volume_file)
info_path = '%s.info' % volume_path
snap_path = '%s.%s' % (volume_path, self.SNAP_UUID)
snap_path_2 = '%s.%s' % (volume_path, self.SNAP_UUID_2)
snap_file = '%s.%s' % (volume_file, self.SNAP_UUID)
snap_file_2 = '%s.%s' % (volume_file, self.SNAP_UUID_2)
mox.StubOutWithMock(drv, '_execute')
mox.StubOutWithMock(drv, '_nova')
mox.StubOutWithMock(drv, '_read_info_file')
mox.StubOutWithMock(drv, '_write_info_file')
mox.StubOutWithMock(os.path, 'exists')
mox.StubOutWithMock(drv, '_get_backing_file_for_path')
mox.StubOutWithMock(db, 'snapshot_get')
snap_info = {
'active': snap_file_2,
self.SNAP_UUID: snap_file,
self.SNAP_UUID_2: snap_file_2
}
drv._read_info_file(info_path).AndReturn(snap_info)
os.path.exists(snap_path).AndReturn(True)
drv._read_info_file(info_path, empty_if_missing=True).\
AndReturn(snap_info)
drv._get_backing_file_for_path(snap_path).AndReturn(volume_file)
delete_info = {
'type': 'qcow2',
'merge_target_file': volume_file,
'file_to_merge': snap_file,
'volume_id': self.VOLUME_UUID
}
drv._nova.delete_volume_snapshot(ctxt, self.SNAP_UUID, delete_info)
drv._read_info_file(info_path).AndReturn(snap_info)
drv._read_info_file(info_path).AndReturn(snap_info)
snap_ref['status'] = 'deleting'
snap_ref['progress'] = '0%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_ref['progress'] = '50%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_ref['progress'] = '90%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
drv._write_info_file(info_path, snap_info)
drv._execute('rm', '-f', snap_path, run_as_root=True)
mox.ReplayAll()
drv.delete_snapshot(snap_ref)
def setUp(self):
super(ExtendedSnapshotAttributesTest, self).setUp()
self.user_ctxt = context.RequestContext(fake.USER_ID,
fake.PROJECT_ID,
auth_token=True)
def setUp(self):
super(VolumeManageTest, self).setUp()
self._admin_ctxt = context.RequestContext(fake.USER_ID,
fake.PROJECT_ID, True)
def setUp(self):
super(MessageApiTest, self).setUp()
self.message_api = message_api.API()
self.mock_object(self.message_api, 'db')
self.ctxt = context.RequestContext('admin', 'fakeproject', True)
self.ctxt.request_id = 'fakerequestid'
def _test_volume_api(self, method, rpc_method, **kwargs):
ctxt = context.RequestContext('fake_user', 'fake_project')
if 'rpcapi_class' in kwargs:
rpcapi_class = kwargs['rpcapi_class']
del kwargs['rpcapi_class']
else:
rpcapi_class = volume_rpcapi.VolumeAPI
rpcapi = rpcapi_class()
expected_retval = 'foo' if method == 'call' else None
target = {
"version": kwargs.pop('version', rpcapi.BASE_RPC_API_VERSION)
}
if 'request_spec' in kwargs:
spec = jsonutils.to_primitive(kwargs['request_spec'])
kwargs['request_spec'] = spec
expected_msg = copy.deepcopy(kwargs)
if 'volume' in expected_msg:
volume = expected_msg['volume']
del expected_msg['volume']
expected_msg['volume_id'] = volume['id']
if 'snapshot' in expected_msg:
snapshot = expected_msg['snapshot']
del expected_msg['snapshot']
expected_msg['snapshot_id'] = snapshot['id']
if 'host' in expected_msg:
del expected_msg['host']
if 'dest_host' in expected_msg:
dest_host = expected_msg['dest_host']
dest_host_dict = {'host': dest_host.host,
'capabilities': dest_host.capabilities}
del expected_msg['dest_host']
expected_msg['host'] = dest_host_dict
if 'new_volume' in expected_msg:
volume = expected_msg['new_volume']
del expected_msg['new_volume']
expected_msg['new_volume_id'] = volume['id']
if 'host' in kwargs:
host = kwargs['host']
else:
host = kwargs['volume']['host']
target['server'] = host
target['topic'] = '%s.%s' % (CONF.volume_topic, host)
self.fake_args = None
self.fake_kwargs = None
def _fake_prepare_method(*args, **kwds):
for kwd in kwds:
self.assertEqual(kwds[kwd], target[kwd])
return rpcapi.client
def _fake_rpc_method(*args, **kwargs):
self.fake_args = args
self.fake_kwargs = kwargs
if expected_retval:
return expected_retval
self.stubs.Set(rpcapi.client, "prepare", _fake_prepare_method)
self.stubs.Set(rpcapi.client, rpc_method, _fake_rpc_method)
retval = getattr(rpcapi, method)(ctxt, **kwargs)
self.assertEqual(retval, expected_retval)
expected_args = [ctxt, method]
for arg, expected_arg in zip(self.fake_args, expected_args):
self.assertEqual(arg, expected_arg)
for kwarg, value in self.fake_kwargs.items():
self.assertEqual(value, expected_msg[kwarg])
def setUp(self):
super(TestGlanceImageServiceClient, self).setUp()
self.context = context.RequestContext('fake', 'fake', auth_token=True)
self.stubs.Set(glance.time, 'sleep', lambda s: None)
def setUp(self):
super(TestCleanable, self).setUp()
self.context = context.RequestContext(self.user_id,
self.project_id,
is_admin=True)
def test_get_backup_under_allowed_api_version(self):
ctx = context.RequestContext(fake.USER2_ID, fake.PROJECT_ID, True)
bak = self._send_backup_request(ctx,
version=mv.get_prior_version(
mv.BACKUP_PROJECT))
self.assertNotIn('os-backup-project-attr:project_id', bak)
def test_get_backup_user_id_before_microversion_v356(self):
ctx = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, True)
bak = self._send_backup_request(ctx,
version=mv.get_prior_version(
mv.BACKUP_PROJECT_USER_ID))
self.assertNotIn('user_id', bak)
def setUp(self):
super(TestGlanceImageServiceClient, self).setUp()
self.context = context.RequestContext('fake', 'fake', auth_token=True)
self.mock_object(glance.time, 'sleep', return_value=None)
service_auth.reset_globals()
def setUp(self):
super(QualityOfServiceSpecsTableTestCase, self).setUp()
self.ctxt = context.RequestContext(user_id='user_id',
project_id='project_id',
is_admin=True)
def test_migrate_volume_same_host(self):
expected_status = 400
host = 'test'
ctx = context.RequestContext('admin', 'fake', True)
volume = self._migrate_volume_prep()
self._migrate_volume_exec(ctx, volume, host, expected_status)
def setUp(self):
super(VolumeTypeTestCase, self).setUp()
self.ctxt = context.RequestContext(user_id=fake.USER_ID,
project_id=fake.PROJECT_ID,
is_admin = True)
def setUp(self):
super(VolumeTransferTestCase, self).setUp()
self.ctxt = context.RequestContext(user_id='user_id',
project_id='project_id')
self.updated_at = datetime.datetime(1, 1, 1, 1, 1, 1)
def setUp(self):
super(MockKeyManagerTestCase, self).setUp()
self.ctxt = context.RequestContext('fake', 'fake')
def setUp(self):
super(SchedulerStatsAPITest, self).setUp()
self.flags(host='fake')
self.controller = scheduler_stats.SchedulerStatsController()
self.ctxt = context.RequestContext('admin', 'fake', True)
def setUp(self):
"""Set up the test case environment.
Defines the mock HTTPS responses for the REST API calls.
"""
super(TestMisc, self).setUp()
self.ctx = context.RequestContext('fake', 'fake', auth_token=True)
self.volume = fake_volume.fake_volume_obj(
self.ctx, **{'name': 'vol1', 'provider_id': fake.PROVIDER_ID}
)
self.new_volume = fake_volume.fake_volume_obj(
self.ctx, **{'name': 'vol2', 'provider_id': fake.PROVIDER2_ID}
)
self.HTTPS_MOCK_RESPONSES = {
self.RESPONSE_MODE.Valid: {
'types/Domain/instances/getByName::{}'.format(
self.PROT_DOMAIN_NAME
): '"{}"'.format(self.PROT_DOMAIN_ID),
'types/Pool/instances/getByName::{},{}'.format(
self.PROT_DOMAIN_ID,
self.STORAGE_POOL_NAME
): '"{}"'.format(self.STORAGE_POOL_ID),
'types/StoragePool/instances/action/querySelectedStatistics': {
'"{}"'.format(self.STORAGE_POOL_NAME): {
'capacityAvailableForVolumeAllocationInKb': 5000000,
'capacityLimitInKb': 16000000,
'spareCapacityInKb': 6000000,
'thickCapacityInUseInKb': 266,
'thinCapacityAllocatedInKm': 0,
'snapCapacityInUseInKb': 266,
},
},
'instances/Volume::{}/action/setVolumeName'.format(
self.volume['provider_id']):
self.new_volume['provider_id'],
'instances/Volume::{}/action/setVolumeName'.format(
self.new_volume['provider_id']):
self.volume['provider_id'],
'version': '"{}"'.format('2.0.1'),
'instances/StoragePool::{}'.format(
self.STORAGE_POOL_ID
): {
'name': self.STORAGE_POOL_NAME,
'id': self.STORAGE_POOL_ID,
'protectionDomainId': self.PROT_DOMAIN_ID,
'zeroPaddingEnabled': 'true',
},
'instances/ProtectionDomain::{}'.format(
self.PROT_DOMAIN_ID
): {
'name': self.PROT_DOMAIN_NAME,
'id': self.PROT_DOMAIN_ID
},
},
self.RESPONSE_MODE.BadStatus: {
'types/Domain/instances/getByName::' +
self.PROT_DOMAIN_NAME: self.BAD_STATUS_RESPONSE,
'instances/Volume::{}/action/setVolumeName'.format(
self.volume['provider_id']): mocks.MockHTTPSResponse(
{
'message': 'Invalid volume.',
'httpStatusCode': 400,
'errorCode': self.VOLUME_NOT_FOUND_ERROR
}, 400),
},
self.RESPONSE_MODE.Invalid: {
'types/Domain/instances/getByName::' +
self.PROT_DOMAIN_NAME: None,
'instances/Volume::{}/action/setVolumeName'.format(
self.volume['provider_id']): mocks.MockHTTPSResponse(
{
'message': 'Invalid volume.',
'httpStatusCode': 400,
'errorCode': 0
}, 400),
},
}
def setUp(self):
super(VolumeReplicationAPITestCase, self).setUp()
self.ctxt = context.RequestContext('admin', 'fake', True)
self.volume_params = {'host': CONF.host, 'size': 1}
def setUp(self):
super(TransfersTableTestCase, self).setUp()
self.ctxt = context.RequestContext(user_id=fake.USER_ID,
project_id=fake.PROJECT_ID)
def setUp(self):
super(CapabilitiesAPITest, self).setUp()
self.flags(host='fake')
self.controller = capabilities.CapabilitiesController()
self.ctxt = context.RequestContext('admin', 'fake', True)
def fake_volume_api_get(*args, **kwargs):
ctx = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, True)
db_volume = fake_db_volume_get(volume_id=kwargs.get('volume_id'))
return fake_volume.fake_volume_obj(ctx, **db_volume)
def setUp(self):
super(SchedulerTestCase, self).setUp()
self.driver = self.driver_cls()
self.context = context.RequestContext(fake.USER_ID, fake.PROJECT_ID)
self.topic = 'fake_topic'
def test_default_admin_role_is_admin(self):
ctx = context.RequestContext('fake', 'fake', roles=['johnny-admin'])
self.assertFalse(ctx.is_admin)
ctx = context.RequestContext('fake', 'fake', roles=['admin'])
self.assertTrue(ctx.is_admin)
def setUp(self):
super(SchedulerDriverModuleTestCase, self).setUp()
self.context = context.RequestContext(fake.USER_ID, fake.PROJECT_ID)
def test_create_snapshot_online_novafailure(self):
(mox, drv) = self._mox, self._driver
volume = self._simple_volume()
volume['status'] = 'in-use'
hashed = drv._get_hash_str(self.TEST_EXPORT1)
volume_file = 'volume-%s' % self.VOLUME_UUID
volume_path = '%s/%s/%s' % (self.TEST_MNT_POINT_BASE, hashed,
volume_file)
info_path = '%s.info' % volume_path
ctxt = context.RequestContext('fake_user', 'fake_project')
snap_ref = {
'name': 'test snap (online)',
'volume_id': self.VOLUME_UUID,
'volume': volume,
'id': self.SNAP_UUID,
'context': ctxt
}
snap_path = '%s.%s' % (volume_path, self.SNAP_UUID)
snap_file = '%s.%s' % (volume_file, self.SNAP_UUID)
mox.StubOutWithMock(drv, '_execute')
mox.StubOutWithMock(drv, '_create_qcow2_snap_file')
mox.StubOutWithMock(drv, '_nova')
mox.StubOutWithMock(db, 'snapshot_get')
mox.StubOutWithMock(drv, '_write_info_file')
drv._create_qcow2_snap_file(snap_ref, volume_file, snap_path)
create_info = {
'snapshot_id': snap_ref['id'],
'type': 'qcow2',
'new_file': snap_file
}
drv._nova.create_volume_snapshot(ctxt, self.VOLUME_UUID, create_info)
snap_ref['status'] = 'creating'
snap_ref['progress'] = '0%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_ref['progress'] = '50%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_ref['progress'] = '99%'
snap_ref['status'] = 'error'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_info = {'active': snap_file, self.SNAP_UUID: snap_file}
drv._write_info_file(info_path, snap_info)
mox.ReplayAll()
self.assertRaises(exception.GlusterfsException, drv.create_snapshot,
snap_ref)
def fake_volume_api_get(*args, **kwargs):
ctx = context.RequestContext('admin', 'fake', True)
db_volume = fake_db_volume_get()
return fake_volume.fake_volume_obj(ctx, **db_volume)
def test_delete_snapshot_online_novafailure(self):
"""Delete the newest snapshot."""
(mox, drv) = self._mox, self._driver
volume = self._simple_volume()
volume['status'] = 'in-use'
ctxt = context.RequestContext('fake_user', 'fake_project')
snap_ref = {
'name': 'test snap to delete (online)',
'volume_id': self.VOLUME_UUID,
'volume': volume,
'id': self.SNAP_UUID,
'context': ctxt
}
hashed = drv._get_hash_str(self.TEST_EXPORT1)
volume_file = 'volume-%s' % self.VOLUME_UUID
volume_path = '%s/%s/%s' % (self.TEST_MNT_POINT_BASE, hashed,
volume_file)
info_path = '%s.info' % volume_path
snap_path = '%s.%s' % (volume_path, self.SNAP_UUID)
snap_file = '%s.%s' % (volume_file, self.SNAP_UUID)
mox.StubOutWithMock(drv, '_execute')
mox.StubOutWithMock(drv, '_nova')
mox.StubOutWithMock(drv, '_read_info_file')
mox.StubOutWithMock(drv, '_write_info_file')
mox.StubOutWithMock(os.path, 'exists')
mox.StubOutWithMock(drv, '_get_backing_file_for_path')
mox.StubOutWithMock(db, 'snapshot_get')
snap_info = {'active': snap_file, self.SNAP_UUID: snap_file}
drv._read_info_file(info_path).AndReturn(snap_info)
os.path.exists(snap_path).AndReturn(True)
drv._read_info_file(info_path, empty_if_missing=True).\
AndReturn(snap_info)
asdfqemu_img_info_output = """image: %s
file format: qcow2
virtual size: 1.0G (1073741824 bytes)
disk size: 173K
backing file: %s
""" % (snap_file, volume_file)
delete_info = {
'type': 'qcow2',
'merge_target_file': None,
'file_to_merge': volume_file,
'volume_id': self.VOLUME_UUID
}
drv._nova.delete_volume_snapshot(ctxt, self.SNAP_UUID, delete_info)
drv._get_backing_file_for_path(snap_path).AndReturn(volume_file)
drv._read_info_file(info_path).AndReturn(snap_info)
drv._read_info_file(info_path).AndReturn(snap_info)
snap_ref['status'] = 'deleting'
snap_ref['progress'] = '0%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_ref['progress'] = '50%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
snap_ref['status'] = 'error_deleting'
snap_ref['progress'] = '90%'
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
db.snapshot_get(ctxt, self.SNAP_UUID).AndReturn(snap_ref)
drv._write_info_file(info_path, snap_info)
drv._execute('rm', '-f', volume_path, run_as_root=True)
mox.ReplayAll()
self.assertRaises(exception.GlusterfsException, drv.delete_snapshot,
snap_ref)
def test_volume_force_detach_raises_remote_error(self):
# admin context
ctx = context.RequestContext('admin', 'fake', True)
# current status is available
volume = db.volume_create(
ctx, {
'status': 'available',
'host': 'test',
'provider_location': '',
'size': 1
})
connector = {'initiator': 'iqn.2012-07.org.fake:01'}
# start service to handle rpc messages for attach requests
svc = self.start_service('volume', host='test')
self.volume_api.reserve_volume(ctx, volume)
mountpoint = '/dev/vbd'
attachment = self.volume_api.attach(ctx, volume, stubs.FAKE_UUID, None,
mountpoint, 'rw')
# volume is attached
volume = db.volume_get(ctx, volume['id'])
self.assertEqual('in-use', volume['status'])
self.assertEqual(stubs.FAKE_UUID, attachment['instance_uuid'])
self.assertEqual(mountpoint, attachment['mountpoint'])
self.assertEqual('attached', attachment['attach_status'])
admin_metadata = volume['volume_admin_metadata']
self.assertEqual(2, len(admin_metadata))
self.assertEqual('readonly', admin_metadata[0]['key'])
self.assertEqual('False', admin_metadata[0]['value'])
self.assertEqual('attached_mode', admin_metadata[1]['key'])
self.assertEqual('rw', admin_metadata[1]['value'])
conn_info = self.volume_api.initialize_connection(
ctx, volume, connector)
self.assertEqual('rw', conn_info['data']['access_mode'])
# build request to force detach
volume_remote_error = \
messaging.RemoteError(exc_type='VolumeAttachmentNotFound')
with mock.patch.object(volume_api.API,
'detach',
side_effect=volume_remote_error):
req = webob.Request.blank('/v2/fake/volumes/%s/action' %
volume['id'])
req.method = 'POST'
req.headers['content-type'] = 'application/json'
body = {'os-force_detach': {'attachment_id': 'fake'}}
req.body = jsonutils.dump_as_bytes(body)
# attach admin context to request
req.environ['cinder.context'] = ctx
# make request
resp = req.get_response(app())
self.assertEqual(400, resp.status_int)
# test for KeyError when missing connector
volume_remote_error = (messaging.RemoteError(exc_type='KeyError'))
with mock.patch.object(volume_api.API,
'detach',
side_effect=volume_remote_error):
req = webob.Request.blank('/v2/fake/volumes/%s/action' %
volume['id'])
req.method = 'POST'
req.headers['content-type'] = 'application/json'
body = {'os-force_detach': {'attachment_id': 'fake'}}
req.body = jsonutils.dump_as_bytes(body)
# attach admin context to request
req.environ['cinder.context'] = ctx
# make request
self.assertRaises(messaging.RemoteError, req.get_response, app())
# test for VolumeBackendAPIException
volume_remote_error = (messaging.RemoteError(
exc_type='VolumeBackendAPIException'))
with mock.patch.object(volume_api.API,
'detach',
side_effect=volume_remote_error):
req = webob.Request.blank('/v2/fake/volumes/%s/action' %
volume['id'])
req.method = 'POST'
req.headers['content-type'] = 'application/json'
body = {
'os-force_detach': {
'attachment_id': 'fake',
'connector': connector
}
}
req.body = jsonutils.dump_as_bytes(body)
# attach admin context to request
req.environ['cinder.context'] = ctx
# make request
self.assertRaises(messaging.RemoteError, req.get_response, app())
# cleanup
svc.stop()
