def test_nova_client_admin_endpoint(self, p_client):
nova.novaclient(self.ctx, admin_endpoint=True)
p_client.assert_called_once_with(
'regularuser', 'token', None,
auth_url='http://novaadmhost:4778/v2/e3f0833dc08b4cea',
insecure=False, cacert=None, timeout=None,
extensions=nova.nova_extensions)
def test_nova_client_regular(self, p_client):
nova.novaclient(self.ctx)
p_client.assert_called_once_with(
'regularuser', 'token', None,
auth_url='http://novahost:8774/v2/e3f0833dc08b4cea',
insecure=False, cacert=None, timeout=None,
extensions=nova.nova_extensions)
def test_nova_client_privileged_user(self, p_client):
nova.novaclient(self.ctx, privileged_user=True)
p_client.assert_called_once_with(
'adminuser', 'strongpassword', None,
auth_url='http://keystonehost:5000/v2.0',
insecure=False, cacert=None, timeout=None,
extensions=nova.nova_extensions)
def test_nova_client_regular(self, p_client):
nova.novaclient(self.ctx)
p_client.assert_called_once_with(
nova.NOVA_API_VERSION,
'regularuser', 'token', None, region_name=None,
auth_url='http://novahost:8774/v2/e3f0833dc08b4cea',
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_privileged_user(self, p_client):
nova.novaclient(self.ctx, privileged_user=True)
p_client.assert_called_once_with(
nova.NOVA_API_VERSION,
'adminuser', 'strongpassword', None, region_name=None,
auth_url='http://keystonehost:5000/v2.0',
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_custom_region(self, p_client):
self.override_config('os_region_name', 'farfaraway')
nova.novaclient(self.ctx)
p_client.assert_called_once_with(
'regularuser', 'token', None, region_name='farfaraway',
auth_url='http://novahost:8774/v2/e3f0833dc08b4cea',
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_privileged_user_custom_auth_url(self, p_client):
self.override_config('os_privileged_user_auth_url',
'http://privatekeystonehost:5000/v2.0')
nova.novaclient(self.ctx, privileged_user=True)
p_client.assert_called_once_with(
'adminuser', 'strongpassword', None, region_name=None,
auth_url='http://privatekeystonehost:5000/v2.0',
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_update_server_volume(self):
nova.novaclient(self.ctx).AndReturn(self.novaclient)
self.mox.StubOutWithMock(self.novaclient.volumes,
'update_server_volume')
self.novaclient.volumes.update_server_volume('server_id', 'attach_id',
'new_volume_id')
self.mox.ReplayAll()
self.api.update_server_volume(self.ctx, 'server_id', 'attach_id',
'new_volume_id')
def test_nova_client_admin_endpoint(self, p_session, p_plugin_loader,
p_client, p_api_version):
nova.novaclient(self.ctx, admin_endpoint=True)
p_plugin_loader.return_value.load_from_options.assert_called_once_with(
auth_url='http://novaadmhost:4778/v2/e3f0833dc08b4cea',
password='******', project_name=None, username='******'
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='adminURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_privileged_user(self, p_session, p_plugin_loader,
p_client, p_api_version):
nova.novaclient(self.ctx, privileged_user=True)
p_plugin_loader.return_value.load_from_options.assert_called_once_with(
auth_url='http://keystonehost:5000/v2.0',
password='******', project_name=None, username='******'
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_custom_region(self, p_session, p_plugin_loader,
p_client, p_api_version):
self.override_config('os_region_name', 'farfaraway')
nova.novaclient(self.ctx)
p_plugin_loader.return_value.load_from_options.assert_called_once_with(
auth_url='http://novahost:8774/v2/e3f0833dc08b4cea',
password='******', project_name=None, username='******'
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name='farfaraway',
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_regular(self, p_session, p_password_plugin, p_client,
p_api_version):
nova.novaclient(self.ctx)
p_password_plugin.assert_called_once_with(
auth_url='http://novahost:8774/v2/e3f0833dc08b4cea',
password='******', project_name=None, username='******',
project_domain_id=None, user_domain_id=None
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_regular_service_catalog(self, p_session,
p_token_plugin, p_client,
p_api_version):
nova.novaclient(self.ctx)
p_token_plugin.assert_called_once_with(
auth_url='http://keystonehostfromsc:5000/v3',
token='token', project_name=None, project_domain_id=None
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='public', cacert='my.ca',
global_request_id=self.ctx.request_id,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_privileged_user_custom_auth_url(self, p_client):
self.override_config('os_privileged_user_auth_url',
'http://privatekeystonehost:5000/v2.0')
nova.novaclient(self.ctx, privileged_user=True)
p_client.assert_called_once_with(
'adminuser',
'strongpassword',
None,
region_name=None,
auth_url='http://privatekeystonehost:5000/v2.0',
insecure=False,
endpoint_type='publicURL',
cacert=None,
timeout=None,
extensions=nova.nova_extensions)
def test_nova_client_privileged_user(self, p_session, p_password_plugin,
p_client, p_api_version):
nova.novaclient(self.ctx, privileged_user=True)
p_password_plugin.assert_called_once()
self.assertEqual('adminuser',
p_password_plugin.call_args[1]['username'])
self.assertEqual('http://keystonehost:5000',
p_password_plugin.call_args[1]['auth_url'])
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='public', cacert='my.ca',
global_request_id=self.ctx.request_id,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_regular(self, p_session, p_plugin_loader, p_client,
p_api_version):
nova.novaclient(self.ctx)
p_plugin_loader.return_value.load_from_options.assert_called_once_with(
auth_url='http://novahost:8774/v2/e3f0833dc08b4cea',
password='******',
project_name=None,
username='******')
p_client.assert_called_once_with(p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value,
region_name=None,
insecure=False,
endpoint_type='publicURL',
cacert=None,
timeout=None,
extensions=nova.nova_extensions)
def _stop_instance_sync(self, context, instance_uuid):
"""
stop instance through nova api.
The method doesn't return until the instance's status is shutoff
:param context:
:param instance_uuid:
:return:
"""
nova_client = nova.novaclient(context)
instance = nova_client.servers.get(instance_uuid)
if instance.status == INSTANCE_STATUS_SHUTOFF:
LOG.info('the instance is already powered off')
return
try:
nova_client.servers.stop(instance_uuid)
except:
LOG.info('stop instance failed for some reason. maybe it is already powered off')
instance = nova_client.servers.get(instance_uuid)
retry_time = 20
while instance.status != INSTANCE_STATUS_SHUTOFF \
and retry_time > 0:
retry_time = retry_time-1
time.sleep(3)
instance = nova_client.servers.get(instance_uuid)
if retry_time == 0:
raise exception.CinderException('stop_instance_sync failed: '
'instance did not shut down after 60s ')
def test_different_host(self, _mock_novaclient):
_mock_novaclient.return_value = fakes.FakeNovaClient()
filt_cls = self.class_map["InstanceLocalityFilter"]()
host = fakes.FakeHostState("host1", {})
uuid = nova.novaclient().servers.create("host2")
filter_properties = {"context": self.context, "scheduler_hints": {"local_to_instance": uuid}}
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_nova_no_extended_server_attributes(self, _mock_novaclient):
_mock_novaclient.return_value = fakes.FakeNovaClient(ext_srv_attr=False)
filt_cls = self.class_map["InstanceLocalityFilter"]()
host = fakes.FakeHostState("host1", {})
uuid = nova.novaclient().servers.create("host1")
filter_properties = {"context": self.context, "scheduler_hints": {"local_to_instance": uuid}}
self.assertRaises(exception.CinderException, filt_cls.host_passes, host, filter_properties)
def test_nova_client_privileged_user_custom_auth_url(self, p_session,
p_password_plugin,
p_client,
p_api_version):
self.override_config('os_privileged_user_auth_url',
'http://privatekeystonehost:5000/v2.0')
nova.novaclient(self.ctx, privileged_user=True)
p_password_plugin.assert_called_once_with(
auth_url='http://privatekeystonehost:5000/v2.0',
password='******', project_name=None, username='******',
project_domain_id=None, user_domain_id=None
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='publicURL', cacert=None,
timeout=None, extensions=nova.nova_extensions)
def test_nova_client_privileged_user(self, p_session, p_password_plugin,
p_client, p_api_version):
nova.novaclient(self.ctx, privileged_user=True)
p_password_plugin.assert_called_once_with(
auth_url='http://keystonehost:5000', default_domain_id=None,
default_domain_name=None, domain_id=None, domain_name=None,
password='******', project_domain_id=None,
project_domain_name=None, project_id=None, project_name=None,
trust_id=None, user_domain_id=None, user_domain_name=None,
user_id=None, username='******'
)
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name=None,
insecure=False, endpoint_type='public', cacert='my.ca',
global_request_id=self.ctx.request_id,
timeout=None, extensions=nova.nova_extensions)
def test_different_host(self, _mock_novaclient):
_mock_novaclient.return_value = fakes.FakeNovaClient()
filt_cls = self.class_map['InstanceLocalityFilter']()
host = fakes.FakeHostState('host1', {})
uuid = nova.novaclient().servers.create('host2')
filter_properties = {'context': self.context,
'scheduler_hints': {'local_to_instance': uuid}}
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def test_different_host(self, _mock_novaclient):
_mock_novaclient.return_value = fakes.FakeNovaClient()
filt_cls = self.class_map['InstanceLocalityFilter']()
host = fakes.FakeHostState('host1', {})
uuid = nova.novaclient().servers.create('host2')
filter_properties = {'context': self.context,
'scheduler_hints': {'local_to_instance': uuid}}
self.assertFalse(filt_cls.host_passes(host, filter_properties))
def __init__(self,context,threadSafePipe,volume,total_size,task_state):
self.threadSafePipe = threadSafePipe
self.context = context
self.volume = volume
self.total_size = total_size
self.task_state = task_state
self._running = False
self.got_exception = False
self.nova_client = nova.novaclient(context)
def test_nova_client_custom_region(self, p_session, p_password_plugin,
p_client, p_api_version):
CONF.set_override('region_name', 'farfaraway', group='nova')
nova.novaclient(self.ctx, privileged_user=True)
# This doesn't impact the password plugin, just make sure it was called
# with expected default values
p_password_plugin.assert_called_once()
self.assertEqual('http://keystonehost:5000',
p_password_plugin.call_args[1]['auth_url'])
self.assertEqual('adminuser',
p_password_plugin.call_args[1]['username'])
p_client.assert_called_once_with(
p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value, region_name='farfaraway',
insecure=False, endpoint_type='public', cacert='my.ca',
global_request_id=self.ctx.request_id,
timeout=None, extensions=nova.nova_extensions)
def _update_vm_task_state(self, context, vm_uuid, task_state):
nova_client = nova.novaclient(context)
instance = nova_client.servers.get(vm_uuid)
if not task_state:
nova_client.servers.set_meta(instance,{'task_state':''})
else:
nova_client.servers.set_meta(instance,{'task_state':task_state})
return instance.__getattr__('OS-EXT-STS:task_state')
def test_nova_client_regular(self, p_session, p_token_plugin, p_client,
p_api_version):
self.override_config('token_auth_url',
'http://keystonehost:5000',
group='nova')
nova.novaclient(self.ctx)
p_token_plugin.assert_called_once_with(
auth_url='http://keystonehost:5000',
token='token',
project_name=None,
project_domain_id=None)
p_client.assert_called_once_with(p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value,
region_name=None,
insecure=False,
endpoint_type='public',
cacert='my.ca',
timeout=None,
extensions=nova.nova_extensions)
def test_nova_no_extended_server_attributes(self, _mock_novaclient):
_mock_novaclient.return_value = fakes.FakeNovaClient(
ext_srv_attr=False)
filt_cls = self.class_map['InstanceLocalityFilter']()
host = fakes.FakeHostState('host1', {})
uuid = nova.novaclient().servers.create('host1')
filter_properties = {'context': self.context,
'scheduler_hints': {'local_to_instance': uuid}}
self.assertRaises(exception.CinderException,
filt_cls.host_passes, host, filter_properties)
def test_same_host(self, _mock_novaclient, fake_extensions):
_mock_novaclient.return_value = fakes.FakeNovaClient()
fake_extensions.return_value = (
fakes.FakeNovaClient().list_extensions.show_all())
filt_cls = self.class_map['InstanceLocalityFilter']()
host = fakes.FakeHostState('host1', {})
uuid = nova.novaclient().servers.create('host1')
filter_properties = {'context': self.context,
'scheduler_hints': {'local_to_instance': uuid}}
self.assertTrue(filt_cls.host_passes(host, filter_properties))
def test_nova_client_set_timings_max_len(self, p_session, p_token_plugin,
p_client, p_api_version):
p_client.return_value = mock.MagicMock(
**{'set_timings_max_len': mock.MagicMock()})
nova.novaclient(self.ctx)
p_token_plugin.assert_called_once_with(
auth_url='http://keystonehostfromsc:5000/v3',
token='token',
project_name=None,
project_domain_id=None)
p_client.assert_called_once_with(p_api_version(nova.NOVA_API_VERSION),
session=p_session.return_value,
region_name=None,
insecure=False,
endpoint_type='public',
cacert='my.ca',
global_request_id=self.ctx.request_id,
timeout=None,
extensions=nova.nova_extensions)
p_client.return_value.set_timings_max_len.assert_called_once_with(
CONF.nova_client.max_timing_buffer)
def _get_vcloud_vapp_name(self, context, volume):
vapp_name = self.db.volume_metadata_get(context,volume['id']).get('vcloud_vapp_name')
if not vapp_name:
nova_client = nova.novaclient(context)
instance_uuid = self._get_instance_uuid(volume)
instance = nova_client.servers.get(instance_uuid)
if CONF.vcloud.vcloud_vm_naming_rule == 'openstack_vm_id':
return instance.uuid
elif CONF.vcloud.vcloud_vm_naming_rule == 'openstack_vm_name':
return instance.uuid
elif CONF.vcloud.vcloud_vm_naming_rule == 'cascaded_openstack_rule':
return instance.name
else:
return instance.uuid
else:
return vapp_name
