def test_bless_instance_migrate(self):
self.vmsconn.set_return_val(
"bless", ("newname", "migration_url", ["file1", "file2", "file3"]))
self.vmsconn.set_return_val("post_bless",
["file1_ref", "file2_ref", "file3_ref"])
self.vmsconn.set_return_val("bless_cleanup", None)
blessed_uuid = utils.create_instance(self.context)
pre_bless_instance = db.instance_get_by_uuid(self.context,
blessed_uuid)
migration_url = self.gridcentric.bless_instance(
self.context,
instance_uuid=blessed_uuid,
migration_url="mcdist://migrate_addr")
post_bless_instance = db.instance_get_by_uuid(self.context,
blessed_uuid)
self.assertEquals(pre_bless_instance['vm_state'],
post_bless_instance['vm_state'])
self.assertEquals("migration_url", migration_url)
metadata = db.instance_metadata_get(self.context, blessed_uuid)
self.assertEquals("file1_ref,file2_ref,file3_ref", metadata['images'])
self.assertEquals(pre_bless_instance['launched_at'],
post_bless_instance['launched_at'])
self.assertFalse(pre_bless_instance.get('disable_terminate', None),
post_bless_instance.get('disable_terminate', None))
def test_bless_instance(self):
instance_uuid = utils.create_instance(self.context)
num_instance_before = len(db.instance_get_all(self.context))
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
self.assertEquals(vm_states.BUILDING, blessed_instance['vm_state'])
# Ensure that we have a 2nd instance in the database that is a "clone"
# of our original instance.
instances = db.instance_get_all(self.context)
self.assertTrue(
len(instances) == (num_instance_before + 1),
"There should be one new instance after blessing.")
# The virtual machine should be marked that it is now blessed.
metadata = db.instance_metadata_get(self.context,
blessed_instance['uuid'])
self.assertTrue(
metadata.has_key('blessed_from'),
"The instance should have a bless metadata after being blessed.")
self.assertTrue(metadata['blessed_from'] == '%s' % instance_uuid,
"The instance should have the blessed_from metadata set to true after being blessed. " \
+ "(value=%s)" % (metadata['blessed_from']))
def test_launch_without_user_data(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
launched_instance = self.gridcentric_api.launch_instance(self.context, blessed_instance_uuid, params={})
user_data = launched_instance['user_data']
self.assertEqual(user_data, '')
def test_launch_instance_twice(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
launched_instance = self.gridcentric_api.launch_instance(
self.context, blessed_instance_uuid)
launched_instance_uuid = launched_instance['uuid']
metadata = db.instance_metadata_get(self.context,
launched_instance['uuid'])
self.assertTrue(
metadata.has_key('launched_from'),
"The instance should have a 'launched from' metadata after being launched."
)
self.assertTrue(metadata['launched_from'] == '%s' % (blessed_instance_uuid),
"The instance should have the 'launched from' metadata set to blessed instanced id after being launched. " \
+ "(value=%s)" % (metadata['launched_from']))
launched_instance = self.gridcentric_api.launch_instance(
self.context, blessed_instance_uuid)
launched_instance_uuid = launched_instance['uuid']
metadata = db.instance_metadata_get(self.context,
launched_instance['uuid'])
self.assertTrue(
metadata.has_key('launched_from'),
"The instance should have a 'launched from' metadata after being launched."
)
self.assertTrue(metadata['launched_from'] == '%s' % (blessed_instance_uuid),
"The instance should have the 'launched from' metadata set to blessed instanced id after being launched. " \
+ "(value=%s)" % (metadata['launched_from']))
def test_launch_no_name(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
launched_instance = self.gridcentric_api.launch_instance(self.context, blessed_instance_uuid, params={})
name = launched_instance['display_name']
self.assertEqual(name, 'None-0-clone')
self.assertEqual(launched_instance['hostname'], 'none-0-clone')
def test_migrate_bad_destination(self):
instance_uuid = utils.create_instance(self.context, {"task_state":task_states.MIGRATING})
try:
self.gridcentric_api.migrate_instance(self.context, instance_uuid, "no_destination")
self.fail("Should not be able to migrate a non-existent destination.")
except exception.NovaException:
pass
def test_launch_not_blessed_image(self):
instance_id = utils.create_instance(self.context)
try:
self.gridcentric.launch_instance(self.context, instance_id)
self.fail("Should not be able to launch and instance that has not been blessed.")
except exception.Error, e:
pass # Success!
def test_launch_with_user_data(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
test_data = "here is some test user data"
test_data_encoded = base64.b64encode(test_data)
launched_instance = self.gridcentric_api.launch_instance(self.context, blessed_instance_uuid, params={'user_data': test_data_encoded})
user_data = launched_instance['user_data']
self.assertEqual(user_data, test_data_encoded)
def test_launch_without_user_data(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
launched_instance = self.gridcentric_api.launch_instance(
self.context, blessed_instance_uuid, params={})
user_data = launched_instance['user_data']
self.assertEqual(user_data, '')
def test_launch_no_name(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
launched_instance = self.gridcentric_api.launch_instance(
self.context, blessed_instance_uuid, params={})
name = launched_instance['display_name']
self.assertEqual(name, 'None-0-clone')
self.assertEqual(launched_instance['hostname'], 'none-0-clone')
def test_reset_host_non_migrating_instance(self):
host = "test-host"
instance_uuid = utils.create_instance(self.context, {'host': host})
self.gridcentric.host = host
self.gridcentric._refresh_host(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(host, instance['host'])
self.assertEquals(None, instance['task_state'])
def test_migrate_migrating_instance(self):
instance_uuid = utils.create_instance(self.context, {"task_state":task_states.MIGRATING})
# Create a service so that one can be found by the api.
utils.create_gridcentric_service(self.context)
try:
self.gridcentric_api.migrate_instance(self.context, instance_uuid, None)
self.fail("Should not be able to migrate a migrating instance.")
except exception.NovaException:
pass
def test_migrate_inactive_instance(self):
instance_uuid = utils.create_instance(self.context, {"vm_state":vm_states.BUILDING})
# Create a service so that one can be found by the api.
utils.create_gridcentric_service(self.context)
try:
self.gridcentric_api.migrate_instance(self.context, instance_uuid, None)
self.fail("Should not be able to migrate an inactive instance.")
except exception.NovaException:
pass
def test_migrate_instance_no_destination(self):
instance_uuid = utils.create_instance(self.context, {"vm_state":vm_states.ACTIVE})
# Create a service so that one can be found by the api.
utils.create_gridcentric_service(self.context)
self.gridcentric_api.migrate_instance(self.context, instance_uuid, None)
instance_ref = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(task_states.MIGRATING, instance_ref['task_state'])
self.assertEquals(vm_states.ACTIVE, instance_ref['vm_state'])
def test_migrate_instance_with_destination(self):
instance_uuid = utils.create_instance(self.context, {"vm_state":vm_states.ACTIVE})
gc_service = utils.create_gridcentric_service(self.context)
dest = gc_service['host']
self.gridcentric_api.migrate_instance(self.context, instance_uuid, dest)
instance_ref = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(task_states.MIGRATING, instance_ref['task_state'])
self.assertEquals(vm_states.ACTIVE, instance_ref['vm_state'])
def test_bless_instance_twice(self):
instance_id = utils.create_instance(self.context)
num_instance_before = len(db.instance_get_all(self.context))
self.gridcentric.bless_instance(self.context, instance_id)
self.gridcentric.bless_instance(self.context, instance_id)
instances = db.instance_get_all(self.context)
self.assertTrue(len(instances) == num_instance_before + 2,
"There should be 2 more instances because we blessed twice.")
def test_migrate_bad_destination(self):
instance_uuid = utils.create_instance(
self.context, {"task_state": task_states.MIGRATING})
try:
self.gridcentric_api.migrate_instance(self.context, instance_uuid,
"no_destination")
self.fail(
"Should not be able to migrate a non-existent destination.")
except exception.NovaException:
pass
def test_launch_not_blessed_image(self):
instance_uuid = utils.create_instance(self.context)
try:
self.gridcentric_api.launch_instance(self.context, instance_uuid)
self.fail(
"Should not be able to launch and instance that has not been blessed."
)
except exception.NovaException, e:
pass # Success!
def test_reset_host_non_migrating_instance(self):
host = "test-host"
instance_uuid = utils.create_instance(self.context,
{'host': host})
self.gridcentric.host = host
self.gridcentric._refresh_host(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(host, instance['host'])
self.assertEquals(None, instance['task_state'])
def test_bless_quota(self):
def assert_quotas(expected_increased):
_pre_usages = dict(pre_usages)
_pre_usages.pop('project_id', None)
post_usages = sqlalchemy_db.quota_usage_get_all_by_project(self.context, self.context.project_id)
# Need to assert something about the quota consumption
for quota_key in ['instances', 'ram', 'cores']:
pre_usage = _pre_usages.pop(quota_key)
self.assertEquals(pre_usage.get('in_use',0) + expected_increased[quota_key],
post_usages[quota_key].get('in_use',0))
self.assertEquals(pre_usage.get('reserved',0), post_usages[quota_key].get('reserved',0))
for key, quota_usage in _pre_usages.iteritems():
self.assertEquals(quota_usage.get('reserved', 0), post_usages[key].get('reserved', 0))
self.assertEquals(quota_usage.get('in_use', 0), post_usages[key].get('in_use', 0))
instance_uuid = utils.create_instance(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
# Set the quota so that we can have two blessed instances (+ the instance we are blessing).
db.quota_create(self.context, self.context.project_id,
'ram', 3 * instance['memory_mb'])
pre_usages = sqlalchemy_db.quota_usage_get_all_by_project(self.context, self.context.project_id)
# The amount of resources a blessed instance consumes.
blessed_uuids = []
for i in range(1, 3):
blessed_uuids.append(
self.gridcentric_api.bless_instance(self.context, instance_uuid)['uuid'])
expected = dict(zip(['instances', 'ram', 'cores'],
map(lambda x: i * x,
[1, instance['memory_mb'], instance['vcpus']])))
assert_quotas(expected)
try:
self.gridcentric_api.bless_instance(self.context, instance_uuid)
self.fail("We should not have the quota to bless one more instance.")
except exception.TooManyInstances:
pass
# Discard the blessed uuid and ensure that the quota increases.
remaining = len(blessed_uuids)
for blessed_uuid in blessed_uuids:
self.gridcentric_api.discard_instance(self.context, blessed_uuid)
remaining -= 1
expected = dict(zip(['instances', 'ram', 'cores'],
map(lambda x: remaining * x,
[1, instance['memory_mb'], instance['vcpus']])))
assert_quotas(expected)
def test_reset_host_different_host_instance(self):
host = "test-host"
instance_uuid = utils.create_instance(self.context,
{'task_state':task_states.MIGRATING,
'host': host})
self.gridcentric.host = 'different-host'
self.gridcentric._refresh_host(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(host, instance['host'])
self.assertEquals(task_states.MIGRATING, instance['task_state'])
def test_migrate_migrating_instance(self):
instance_uuid = utils.create_instance(
self.context, {"task_state": task_states.MIGRATING})
# Create a service so that one can be found by the api.
utils.create_gridcentric_service(self.context)
try:
self.gridcentric_api.migrate_instance(self.context, instance_uuid,
None)
self.fail("Should not be able to migrate a migrating instance.")
except exception.NovaException:
pass
def test_launch_with_security_groups(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(self.context,
instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
sg = utils.create_security_group(self.context,
{'name': 'test-sg',
'description': 'test security group'})
inst = self.gridcentric_api.launch_instance(self.context,
blessed_instance_uuid, params={'security_groups': ['test-sg']})
self.assertEqual(inst['security_groups'][0].id, sg.id)
self.assertEqual(1, len(inst['security_groups']))
def test_bless_a_blessed_instance(self):
instance_id = utils.create_instance(self.context)
self.gridcentric.bless_instance(self.context, instance_id)
blessed_id = instance_id + 1
no_exception = False
try:
self.gridcentric.bless_instance(self.context, blessed_id)
no_exception = True
except Exception, e:
pass # success
def test_migrate_instance_no_destination(self):
instance_uuid = utils.create_instance(self.context,
{"vm_state": vm_states.ACTIVE})
# Create a service so that one can be found by the api.
utils.create_gridcentric_service(self.context)
self.gridcentric_api.migrate_instance(self.context, instance_uuid,
None)
instance_ref = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(task_states.MIGRATING, instance_ref['task_state'])
self.assertEquals(vm_states.ACTIVE, instance_ref['vm_state'])
def test_migrate_inactive_instance(self):
instance_uuid = utils.create_instance(self.context,
{"vm_state": vm_states.BUILDING})
# Create a service so that one can be found by the api.
utils.create_gridcentric_service(self.context)
try:
self.gridcentric_api.migrate_instance(self.context, instance_uuid,
None)
self.fail("Should not be able to migrate an inactive instance.")
except exception.NovaException:
pass
def test_check_delete(self):
instance_uuid = utils.create_instance(self.context)
# This should not raise an error because the instance is not blessed.
self.gridcentric_api.check_delete(self.context, instance_uuid)
blessed_instance_uuid = utils.create_blessed_instance(self.context)
try:
self.gridcentric_api.check_delete(self.context, blessed_instance_uuid)
self.fail("Check delete should fail for a blessed instance.")
except exception.NovaException:
pass
def test_migrate_instance_with_destination(self):
instance_uuid = utils.create_instance(self.context,
{"vm_state": vm_states.ACTIVE})
gc_service = utils.create_gridcentric_service(self.context)
dest = gc_service['host']
self.gridcentric_api.migrate_instance(self.context, instance_uuid,
dest)
instance_ref = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(task_states.MIGRATING, instance_ref['task_state'])
self.assertEquals(vm_states.ACTIVE, instance_ref['vm_state'])
def test_bless_instance_twice(self):
instance_uuid = utils.create_instance(self.context)
num_instance_before = len(db.instance_get_all(self.context))
self.gridcentric_api.bless_instance(self.context, instance_uuid)
self.gridcentric_api.bless_instance(self.context, instance_uuid)
instances = db.instance_get_all(self.context)
self.assertTrue(
len(instances) == num_instance_before + 2,
"There should be 2 more instances because we blessed twice.")
def test_bless_a_blessed_instance(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(self.context, instance_uuid)
blessed_uuid = blessed_instance['uuid']
no_exception = False
try:
self.gridcentric_api.bless_instance(self.context, blessed_uuid)
no_exception = True
except Exception, e:
pass # success
def test_reset_host_different_host_instance(self):
host = "test-host"
instance_uuid = utils.create_instance(self.context, {
'task_state': task_states.MIGRATING,
'host': host
})
self.gridcentric.host = 'different-host'
self.gridcentric._refresh_host(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(host, instance['host'])
self.assertEquals(task_states.MIGRATING, instance['task_state'])
def test_check_delete(self):
instance_uuid = utils.create_instance(self.context)
# This should not raise an error because the instance is not blessed.
self.gridcentric_api.check_delete(self.context, instance_uuid)
blessed_instance_uuid = utils.create_blessed_instance(self.context)
try:
self.gridcentric_api.check_delete(self.context,
blessed_instance_uuid)
self.fail("Check delete should fail for a blessed instance.")
except exception.NovaException:
pass
def test_bless_a_non_active_instance(self):
instance_id = utils.create_instance(self.context, {'vm_state':vm_states.BUILDING})
no_exception = False
try:
self.gridcentric.bless_instance(self.context, instance_id)
no_exception = True
except:
pass # success
if no_exception:
self.fail("Should not be able to bless an instance in a non-active state")
def test_launch_with_user_data(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
test_data = "here is some test user data"
test_data_encoded = base64.b64encode(test_data)
launched_instance = self.gridcentric_api.launch_instance(
self.context,
blessed_instance_uuid,
params={'user_data': test_data_encoded})
user_data = launched_instance['user_data']
self.assertEqual(user_data, test_data_encoded)
def test_discard_a_blessed_instance(self):
instance_id = utils.create_instance(self.context)
self.gridcentric.bless_instance(self.context, instance_id)
blessed_id = instance_id + 1
self.gridcentric.discard_instance(self.context, blessed_id)
try:
db.instance_get(self.context, blessed_id)
self.fail("The blessed instance should no longer exists after being discarded.")
except exception.InstanceNotFound:
pass
def test_launch_default_security_group(self):
sg = utils.create_security_group(self.context, {
'name': 'test-sg',
'description': 'test security group'
})
instance_uuid = utils.create_instance(
self.context, {'security_groups': [sg['name']]})
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_instance_uuid = blessed_instance['uuid']
inst = self.gridcentric_api.launch_instance(self.context,
blessed_instance_uuid,
params={})
self.assertEqual(inst['security_groups'][0].id, sg.id)
def test_launch_instance(self):
instance_id = utils.create_instance(self.context)
self.gridcentric.bless_instance(self.context, instance_id)
blessed_instance_id = instance_id + 1
self.gridcentric.launch_instance(self.context, blessed_instance_id)
launched_instance_id = blessed_instance_id + 1
metadata = db.instance_metadata_get(self.context, launched_instance_id)
self.assertTrue(metadata.has_key('launched_from'),
"The instance should have a 'launched from' metadata after being launched.")
self.assertTrue(metadata['launched_from'] == '%s' % (blessed_instance_id),
"The instance should have the 'launched from' metadata set to blessed instanced id after being launched. " \
+ "(value=%s)" % (metadata['launched_from']))
def test_bless_a_blessed_instance(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(self.context, instance_uuid)
blessed_uuid = blessed_instance['uuid']
no_exception = False
try:
self.gridcentric_api.bless_instance(self.context, blessed_uuid)
no_exception = True
except Exception:
pass # success
if no_exception:
self.fail("Should not be able to bless a blessed instance.")
def test_launch_instance_migrate(self):
self.vmsconn.set_return_val("launch", None)
instance_uuid = utils.create_instance(self.context, {'vm_state': vm_states.ACTIVE})
pre_launch_instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.gridcentric.launch_instance(self.context, instance_uuid=instance_uuid,
migration_url="migration_url")
post_launch_instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(vm_states.ACTIVE, post_launch_instance['vm_state'])
self.assertEquals(None, post_launch_instance['task_state'])
self.assertEquals(pre_launch_instance['launched_at'], post_launch_instance['launched_at'])
self.assertEquals(self.gridcentric.host, post_launch_instance['host'])
def test_reset_host_not_local_src(self):
src_host = "src-test-host"
dst_host = "dst-test-host"
instance_uuid = utils.create_instance(self.context,
{'task_state':task_states.MIGRATING,
'host': src_host,
'metadata': {'gc_src_host': src_host,
'gc_dst_host': dst_host}})
self.gridcentric.host = src_host
self.gridcentric._refresh_host(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(dst_host, instance['host'])
self.assertEquals(task_states.MIGRATING, instance['task_state'])
def test_bless_a_non_active_instance(self):
instance_uuid = utils.create_instance(self.context,
{'vm_state': vm_states.BUILDING})
no_exception = False
try:
self.gridcentric_api.bless_instance(self.context, instance_uuid)
no_exception = True
except:
pass # success
if no_exception:
self.fail(
"Should not be able to bless an instance in a non-active state"
)
def test_bless_a_blessed_instance(self):
instance_uuid = utils.create_instance(self.context)
blessed_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_uuid = blessed_instance['uuid']
no_exception = False
try:
self.gridcentric_api.bless_instance(self.context, blessed_uuid)
no_exception = True
except Exception:
pass # success
if no_exception:
self.fail("Should not be able to bless a blessed instance.")
def test_discard_a_blessed_instance_with_remaining_launched_ones(self):
instance_id = utils.create_instance(self.context)
self.gridcentric.bless_instance(self.context, instance_id)
blessed_id = instance_id + 1
self.gridcentric.launch_instance(self.context, blessed_id)
no_exception = False
try:
self.gridcentric.discard_instance(self.context, blessed_id)
no_exception = True
except:
pass # success
if no_exception:
self.fail("Should not be able to discard a blessed instance while launched ones still remain.")
def test_bless_a_launched_instance(self):
instance_id = utils.create_instance(self.context)
self.gridcentric.bless_instance(self.context, instance_id)
blessed_id = instance_id + 1
self.gridcentric.launch_instance(self.context, blessed_id)
launched_id = blessed_id + 1
no_exception = False
try:
self.gridcentric.bless_instance(self.context, launched_id)
no_exception = True
except:
pass # success
if no_exception:
self.fail("Should not be able to bless a launched instance.")
def test_bless_instance(self):
instance_id = utils.create_instance(self.context)
num_instance_before = len(db.instance_get_all(self.context))
self.gridcentric.bless_instance(self.context, instance_id)
# Ensure that we have a 2nd instance in the database that is a "clone"
# of our original instance.
instances = db.instance_get_all(self.context)
self.assertTrue(len(instances) == (num_instance_before + 1),
"There should be one new instances after blessing.")
# The virtual machine should be marked that it is now blessed.
metadata = db.instance_metadata_get(self.context, instance_id + 1)
self.assertTrue(metadata.has_key('blessed'),
"The instance should have a bless metadata after being blessed.")
self.assertTrue(metadata['blessed'] == '1',
"The instance should have the bless metadata set to true after being blessed. " \
+ "(value=%s)" % (metadata['blessed']))
def test_launch_instance_migrate_exception(self):
self.vmsconn.set_return_val("launch", utils.TestInducedException())
launched_uuid = utils.create_instance(self.context, {'vm_state': vm_states.ACTIVE})
try:
self.gridcentric.launch_instance(self.context, instance_uuid=launched_uuid,
migration_url="migration_url")
self.fail("The launch error should have been re-raised up.")
except utils.TestInducedException:
pass
launched_instance = db.instance_get_by_uuid(self.context, launched_uuid)
# (dscannell): This needs to be fixed up once we have the migration state transitions
# performed correctly.
self.assertEquals(vm_states.ACTIVE, launched_instance['vm_state'])
self.assertEquals(task_states.SPAWNING, launched_instance['task_state'])
self.assertEquals(None, launched_instance['launched_at'])
self.assertEquals(None, launched_instance['host'])
def test_bless_instance_migrate(self):
self.vmsconn.set_return_val("bless",
("newname", "migration_url", ["file1", "file2", "file3"]))
self.vmsconn.set_return_val("post_bless", ["file1_ref", "file2_ref", "file3_ref"])
self.vmsconn.set_return_val("bless_cleanup", None)
blessed_uuid = utils.create_instance(self.context)
pre_bless_instance = db.instance_get_by_uuid(self.context, blessed_uuid)
migration_url = self.gridcentric.bless_instance(self.context, instance_uuid=blessed_uuid,
migration_url="mcdist://migrate_addr")
post_bless_instance = db.instance_get_by_uuid(self.context, blessed_uuid)
self.assertEquals(pre_bless_instance['vm_state'], post_bless_instance['vm_state'])
self.assertEquals("migration_url", migration_url)
metadata = db.instance_metadata_get(self.context, blessed_uuid)
self.assertEquals("file1_ref,file2_ref,file3_ref", metadata['images'])
self.assertEquals(pre_bless_instance['launched_at'], post_bless_instance['launched_at'])
self.assertFalse(pre_bless_instance.get('disable_terminate', None),
post_bless_instance.get('disable_terminate', None))
def test_reset_host_not_local_src(self):
src_host = "src-test-host"
dst_host = "dst-test-host"
instance_uuid = utils.create_instance(
self.context, {
'task_state': task_states.MIGRATING,
'host': src_host,
'metadata': {
'gc_src_host': src_host,
'gc_dst_host': dst_host
}
})
self.gridcentric.host = src_host
self.gridcentric._refresh_host(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
self.assertEquals(dst_host, instance['host'])
self.assertEquals(task_states.MIGRATING, instance['task_state'])
def test_discard_a_blessed_instance_with_remaining_launched_ones(self):
instance_uuid = utils.create_instance(self.context)
bless_instance = self.gridcentric_api.bless_instance(
self.context, instance_uuid)
blessed_uuid = bless_instance['uuid']
self.gridcentric_api.launch_instance(self.context, blessed_uuid)
no_exception = False
try:
self.gridcentric_api.discard_instance(self.context, blessed_uuid)
no_exception = True
except:
pass # success
if no_exception:
self.fail(
"Should not be able to discard a blessed instance while launched ones still remain."
)
def test_launch_instance_migrate(self):
self.vmsconn.set_return_val("launch", None)
instance_uuid = utils.create_instance(self.context,
{'vm_state': vm_states.ACTIVE})
pre_launch_instance = db.instance_get_by_uuid(self.context,
instance_uuid)
self.gridcentric.launch_instance(self.context,
instance_uuid=instance_uuid,
migration_url="migration_url")
post_launch_instance = db.instance_get_by_uuid(self.context,
instance_uuid)
self.assertEquals(vm_states.ACTIVE, post_launch_instance['vm_state'])
self.assertEquals(None, post_launch_instance['task_state'])
self.assertEquals(pre_launch_instance['launched_at'],
post_launch_instance['launched_at'])
self.assertEquals(self.gridcentric.host, post_launch_instance['host'])
def test_bless_instance(self):
instance_uuid = utils.create_instance(self.context)
num_instance_before = len(db.instance_get_all(self.context))
blessed_instance = self.gridcentric_api.bless_instance(self.context, instance_uuid)
self.assertEquals(vm_states.BUILDING, blessed_instance['vm_state'])
# Ensure that we have a 2nd instance in the database that is a "clone"
# of our original instance.
instances = db.instance_get_all(self.context)
self.assertTrue(len(instances) == (num_instance_before + 1),
"There should be one new instance after blessing.")
# The virtual machine should be marked that it is now blessed.
metadata = db.instance_metadata_get(self.context, blessed_instance['uuid'])
self.assertTrue(metadata.has_key('blessed_from'),
"The instance should have a bless metadata after being blessed.")
self.assertTrue(metadata['blessed_from'] == '%s' % instance_uuid,
"The instance should have the blessed_from metadata set to true after being blessed. " \
+ "(value=%s)" % (metadata['blessed_from']))
def test_launch_instance_migrate_exception(self):
self.vmsconn.set_return_val("launch", utils.TestInducedException())
launched_uuid = utils.create_instance(self.context,
{'vm_state': vm_states.ACTIVE})
try:
self.gridcentric.launch_instance(self.context,
instance_uuid=launched_uuid,
migration_url="migration_url")
self.fail("The launch error should have been re-raised up.")
except utils.TestInducedException:
pass
launched_instance = db.instance_get_by_uuid(self.context,
launched_uuid)
# (dscannell): This needs to be fixed up once we have the migration state transitions
# performed correctly.
self.assertEquals(vm_states.ACTIVE, launched_instance['vm_state'])
self.assertEquals(task_states.SPAWNING,
launched_instance['task_state'])
self.assertEquals(None, launched_instance['launched_at'])
self.assertEquals(None, launched_instance['host'])
def test_bless_quota(self):
def assert_quotas(expected_increased):
_pre_usages = dict(pre_usages)
_pre_usages.pop('project_id', None)
post_usages = sqlalchemy_db.quota_usage_get_all_by_project(
self.context, self.context.project_id)
# Need to assert something about the quota consumption
for quota_key in ['instances', 'ram', 'cores']:
pre_usage = _pre_usages.pop(quota_key)
self.assertEquals(
pre_usage.get('in_use', 0) + expected_increased[quota_key],
post_usages[quota_key].get('in_use', 0))
self.assertEquals(pre_usage.get('reserved', 0),
post_usages[quota_key].get('reserved', 0))
for key, quota_usage in _pre_usages.iteritems():
self.assertEquals(quota_usage.get('reserved', 0),
post_usages[key].get('reserved', 0))
self.assertEquals(quota_usage.get('in_use', 0),
post_usages[key].get('in_use', 0))
instance_uuid = utils.create_instance(self.context)
instance = db.instance_get_by_uuid(self.context, instance_uuid)
# Set the quota so that we can have two blessed instances (+ the instance we are blessing).
db.quota_create(self.context, self.context.project_id, 'ram',
3 * instance['memory_mb'])
pre_usages = sqlalchemy_db.quota_usage_get_all_by_project(
self.context, self.context.project_id)
# The amount of resources a blessed instance consumes.
blessed_uuids = []
for i in range(1, 3):
blessed_uuids.append(
self.gridcentric_api.bless_instance(self.context,
instance_uuid)['uuid'])
expected = dict(
zip(['instances', 'ram', 'cores'],
map(lambda x: i * x,
[1, instance['memory_mb'], instance['vcpus']])))
assert_quotas(expected)
try:
self.gridcentric_api.bless_instance(self.context, instance_uuid)
self.fail(
"We should not have the quota to bless one more instance.")
except exception.TooManyInstances:
pass
# Discard the blessed uuid and ensure that the quota increases.
remaining = len(blessed_uuids)
for blessed_uuid in blessed_uuids:
self.gridcentric_api.discard_instance(self.context, blessed_uuid)
remaining -= 1
expected = dict(
zip(['instances', 'ram', 'cores'],
map(lambda x: remaining * x,
[1, instance['memory_mb'], instance['vcpus']])))
assert_quotas(expected)