def test_upgrade(self, task_upgrade):
instance_model = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestUpgradeInstance",
datastore_version_id=self.datastore_version1.id)
instance_model.set_task_status(InstanceTasks.NONE)
instance_model.save()
instance_status = InstanceServiceStatus(
ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=instance_model.id)
instance_status.save()
self.assertIsNotNone(instance_model)
instance = models.load_instance(models.Instance, self.context,
instance_model.id)
try:
instance.upgrade(self.datastore_version2)
self.assertEqual(self.datastore_version2.id,
instance.db_info.datastore_version_id)
self.assertEqual(InstanceTasks.UPGRADING,
instance.db_info.task_status)
self.assertTrue(task_upgrade.called)
finally:
instance_status.delete()
instance_model.delete()
def build_db_instance(self, status, task_status=InstanceTasks.NONE):
version = datastore_models.DBDatastoreVersion.get_by(name='5.5')
instance = DBInstance(InstanceTasks.NONE,
name='test_name',
id=str(uuid.uuid4()),
flavor_id='flavor_1',
datastore_version_id=
version.id,
compute_instance_id='compute_id_1',
server_id='server_id_1',
tenant_id='tenant_id_1',
server_status=
rd_instance.ServiceStatuses.
BUILDING.api_status,
deleted=False)
instance.save()
service_status = InstanceServiceStatus(
rd_instance.ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=instance.id,
)
service_status.save()
instance.set_task_status(task_status)
instance.server_status = status
instance.save()
return instance, service_status
def test_upgrade(self, task_upgrade):
instance_model = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestUpgradeInstance",
datastore_version_id=self.datastore_version1.id)
instance_model.set_task_status(InstanceTasks.NONE)
instance_model.save()
instance_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=instance_model.id)
instance_status.save()
self.assertIsNotNone(instance_model)
instance = models.load_instance(models.Instance, self.context,
instance_model.id)
try:
instance.upgrade(self.datastore_version2)
self.assertEqual(self.datastore_version2.id,
instance.db_info.datastore_version_id)
self.assertEqual(InstanceTasks.UPGRADING,
instance.db_info.task_status)
self.assertTrue(task_upgrade.called)
finally:
instance_status.delete()
instance_model.delete()
class TestReplication(TestCase):
def setUp(self):
util.init_db()
self.replica_datastore_version = Mock(spec=DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.root_info = DBInstance(
InstanceTasks.NONE,
id="Another_instance",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id)
self.root_info.save()
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id="Another_instance")
self.replica_info.save()
self.safe_nova = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def tearDown(self):
models.create_nova_client = self.safe_nova
self.replica_info.delete()
self.root_info.delete()
super(TestReplication, self).tearDown()
def test_create_replica_from_replica(self):
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
2,
"UUID", [], [],
None,
self.replica_datastore_version,
1,
None,
slave_of_id=self.replica_info.id)
def build_db_instance(self, status, task_status=InstanceTasks.NONE):
instance = DBInstance(InstanceTasks.NONE,
name='test_name',
id=str(uuid.uuid4()),
flavor_id='flavor_1',
datastore_version_id=self.version.id,
compute_instance_id='compute_id_1',
server_id='server_id_1',
tenant_id='tenant_id_1',
server_status=rd_instance.ServiceStatuses.
BUILDING.api_status,
deleted=False)
instance.save()
service_status = InstanceServiceStatus(
rd_instance.ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=instance.id,
)
service_status.save()
instance.set_task_status(task_status)
instance.server_status = status
instance.save()
return instance, service_status
class TestReplication(TestCase):
def setUp(self):
util.init_db()
self.replica_datastore_version = Mock(spec=DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.root_info = DBInstance(
InstanceTasks.NONE,
id="Another_instance",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id)
self.root_info.save()
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id="Another_instance")
self.replica_info.save()
self.safe_nova = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def tearDown(self):
models.create_nova_client = self.safe_nova
self.replica_info.delete()
self.root_info.delete()
super(TestReplication, self).tearDown()
def test_create_replica_from_replica(self):
self.assertRaises(exception.Forbidden, Instance.create,
None, 'name', 2, "UUID", [], [], None,
self.replica_datastore_version, 1,
None, slave_of_id=self.replica_info.id)
class TestReplication(TestCase):
def setUp(self):
util.init_db()
self.datastore = datastore_models.DBDatastore.create(
id=str(uuid.uuid4()),
name='name',
default_version_id=str(uuid.uuid4()))
self.datastore_version = datastore_models.DBDatastoreVersion.create(
id=self.datastore.default_version_id,
name='name',
image_id=str(uuid.uuid4()),
packages=str(uuid.uuid4()),
datastore_id=self.datastore.id,
manager='mysql',
active=1)
self.master = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestMasterInstance",
datastore_version_id=self.datastore_version.id)
self.master.set_task_status(InstanceTasks.NONE)
self.master.save()
self.master_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=self.master.id)
self.master_status.save()
self.safe_nova_client = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
def test_replica_of_not_active_master(self):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
self.master_status.save()
self.assertRaises(exception.UnprocessableEntity,
Instance.create,
None,
'name',
1,
"UUID", [], [],
None,
self.datastore_version,
1,
None,
slave_of_id=self.master.id)
def test_replica_with_invalid_slave_of_id(self):
self.assertRaises(exception.NotFound,
Instance.create,
None,
'name',
1,
"UUID", [], [],
None,
self.datastore_version,
1,
None,
slave_of_id=str(uuid.uuid4()))
def test_create_replica_from_replica(self):
self.replica_datastore_version = Mock(
spec=datastore_models.DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id=self.master.id)
self.replica_info.save()
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
2,
"UUID", [], [],
None,
self.datastore_version,
1,
None,
slave_of_id=self.replica_info.id)
class TestReplication(TestCase):
def setUp(self):
util.init_db()
self.datastore = datastore_models.DBDatastore.create(
id=str(uuid.uuid4()), name="name", default_version_id=str(uuid.uuid4())
)
self.datastore_version = datastore_models.DBDatastoreVersion.create(
id=self.datastore.default_version_id,
name="name",
image_id=str(uuid.uuid4()),
packages=str(uuid.uuid4()),
datastore_id=self.datastore.id,
manager="mysql",
active=1,
)
self.master = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestMasterInstance",
datastore_version_id=self.datastore_version.id,
)
self.master.set_task_status(InstanceTasks.NONE)
self.master.save()
self.master_status = InstanceServiceStatus(
ServiceStatuses.RUNNING, id=str(uuid.uuid4()), instance_id=self.master.id
)
self.master_status.save()
self.safe_nova_client = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
super(TestReplication, self).setUp()
def tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
def test_replica_of_not_active_master(self):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
self.master_status.save()
self.assertRaises(
exception.UnprocessableEntity,
Instance.create,
None,
"name",
1,
"UUID",
[],
[],
None,
self.datastore_version,
1,
None,
slave_of_id=self.master.id,
)
def test_replica_with_invalid_slave_of_id(self):
self.assertRaises(
exception.NotFound,
Instance.create,
None,
"name",
1,
"UUID",
[],
[],
None,
self.datastore_version,
1,
None,
slave_of_id=str(uuid.uuid4()),
)
def test_create_replica_from_replica(self):
self.replica_datastore_version = Mock(spec=datastore_models.DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = "mysql"
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id=self.master.id,
)
self.replica_info.save()
self.assertRaises(
exception.Forbidden,
Instance.create,
None,
"name",
2,
"UUID",
[],
[],
None,
self.datastore_version,
1,
None,
slave_of_id=self.replica_info.id,
)
def setUp(self):
super(BuiltInstanceTasksTest, self).setUp()
self.new_flavor = {'id': 8, 'ram': 768, 'name': 'bigger_flavor'}
stub_nova_server = MagicMock()
self.rpc_patches = patch.multiple(
rpc, get_notifier=MagicMock(), get_client=MagicMock())
self.rpc_mocks = self.rpc_patches.start()
self.addCleanup(self.rpc_patches.stop)
db_instance = DBInstance(InstanceTasks.NONE,
id=INST_ID,
name='resize-inst-name',
datastore_version_id='1',
datastore_id='id-1',
flavor_id='6',
manager='mysql',
created=datetime.datetime.utcnow(),
updated=datetime.datetime.utcnow(),
compute_instance_id='computeinst-id-1',
tenant_id='testresize-tenant-id',
volume_size='1',
volume_id=VOLUME_ID)
# this is used during the final check of whether the resize successful
db_instance.server_status = 'ACTIVE'
self.db_instance = db_instance
self.dm_dv_load_by_uuid_patch = patch.object(
datastore_models.DatastoreVersion, 'load_by_uuid', MagicMock(
return_value=datastore_models.DatastoreVersion(db_instance)))
self.dm_dv_load_by_uuid_mock = self.dm_dv_load_by_uuid_patch.start()
self.addCleanup(self.dm_dv_load_by_uuid_patch.stop)
self.dm_ds_load_patch = patch.object(
datastore_models.Datastore, 'load', MagicMock(
return_value=datastore_models.Datastore(db_instance)))
self.dm_ds_load_mock = self.dm_ds_load_patch.start()
self.addCleanup(self.dm_ds_load_patch.stop)
self.instance_task = taskmanager_models.BuiltInstanceTasks(
trove.common.context.TroveContext(),
db_instance,
stub_nova_server,
InstanceServiceStatus(ServiceStatuses.RUNNING,
id='inst-stat-id-0'))
self.instance_task._guest = MagicMock(spec=trove.guestagent.api.API)
self.instance_task._nova_client = MagicMock(
spec=novaclient.v2.Client)
self.stub_server_mgr = MagicMock(
spec=novaclient.v2.servers.ServerManager)
self.stub_running_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_running_server.status = 'ACTIVE'
self.stub_running_server.flavor = {'id': 6, 'ram': 512}
self.stub_verifying_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_verifying_server.status = 'VERIFY_RESIZE'
self.stub_verifying_server.flavor = {'id': 8, 'ram': 768}
self.stub_server_mgr.get = MagicMock(
return_value=self.stub_verifying_server)
self.instance_task._nova_client.servers = self.stub_server_mgr
stub_flavor_manager = MagicMock(
spec=novaclient.v2.flavors.FlavorManager)
self.instance_task._nova_client.flavors = stub_flavor_manager
nova_flavor = novaclient.v2.flavors.Flavor(stub_flavor_manager,
self.new_flavor,
True)
stub_flavor_manager.get = MagicMock(return_value=nova_flavor)
answers = (status for status in
self.get_inst_service_status('inst_stat-id',
[ServiceStatuses.SHUTDOWN,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING]))
def side_effect_func(*args, **kwargs):
if 'instance_id' in kwargs:
return answers.next()
elif ('id' in kwargs and 'deleted' in kwargs
and not kwargs['deleted']):
return db_instance
else:
return MagicMock()
self.dbm_dbmb_patch = patch.object(
trove.db.models.DatabaseModelBase, 'find_by',
MagicMock(side_effect=side_effect_func))
self.dbm_dbmb_mock = self.dbm_dbmb_patch.start()
self.addCleanup(self.dbm_dbmb_patch.stop)
self.template_patch = patch.object(
template, 'SingleInstanceConfigTemplate',
MagicMock(spec=template.SingleInstanceConfigTemplate))
self.template_mock = self.template_patch.start()
self.addCleanup(self.template_patch.stop)
db_instance.save = MagicMock(return_value=None)
self.tbmb_running_patch = patch.object(
trove.backup.models.Backup, 'running',
MagicMock(return_value=None))
self.tbmb_running_mock = self.tbmb_running_patch.start()
self.addCleanup(self.tbmb_running_patch.stop)
if 'volume' in self._testMethodName:
self._stub_volume_client()
stub_floating_ips_manager = MagicMock(
spec=novaclient.v2.floating_ips.FloatingIPManager)
self.instance_task._nova_client.floating_ips = (
stub_floating_ips_manager)
floatingip = novaclient.v2.floating_ips.FloatingIP(
stub_floating_ips_manager, {'ip': '192.168.10.1'}, True)
stub_floating_ips_manager.list = MagicMock(return_value=[floatingip])
def setUp(self):
super(BuiltInstanceTasksTest, self).setUp()
self.new_flavor = {'id': 8, 'ram': 768, 'name': 'bigger_flavor'}
stub_nova_server = MagicMock()
self.rpc_patches = patch.multiple(
rpc, get_notifier=MagicMock(), get_client=MagicMock())
self.rpc_mocks = self.rpc_patches.start()
self.addCleanup(self.rpc_patches.stop)
db_instance = DBInstance(InstanceTasks.NONE,
id=INST_ID,
name='resize-inst-name',
datastore_version_id='1',
datastore_id='id-1',
flavor_id='6',
manager='mysql',
created=datetime.datetime.utcnow(),
updated=datetime.datetime.utcnow(),
compute_instance_id='computeinst-id-1',
tenant_id='testresize-tenant-id',
volume_size='1',
volume_id=VOLUME_ID)
# this is used during the final check of whether the resize successful
db_instance.server_status = 'ACTIVE'
self.db_instance = db_instance
self.dm_dv_load_by_uuid_patch = patch.object(
datastore_models.DatastoreVersion, 'load_by_uuid', MagicMock(
return_value=datastore_models.DatastoreVersion(db_instance)))
self.dm_dv_load_by_uuid_mock = self.dm_dv_load_by_uuid_patch.start()
self.addCleanup(self.dm_dv_load_by_uuid_patch.stop)
self.dm_ds_load_patch = patch.object(
datastore_models.Datastore, 'load', MagicMock(
return_value=datastore_models.Datastore(db_instance)))
self.dm_ds_load_mock = self.dm_ds_load_patch.start()
self.addCleanup(self.dm_ds_load_patch.stop)
self.instance_task = taskmanager_models.BuiltInstanceTasks(
trove.common.context.TroveContext(),
db_instance,
stub_nova_server,
InstanceServiceStatus(ServiceStatuses.RUNNING,
id='inst-stat-id-0'))
self.instance_task._guest = MagicMock(spec=trove.guestagent.api.API)
self.instance_task._nova_client = MagicMock(
spec=novaclient.client)
self.stub_server_mgr = MagicMock(
spec=novaclient.v2.servers.ServerManager)
self.stub_running_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_running_server.status = 'ACTIVE'
self.stub_running_server.flavor = {'id': 6, 'ram': 512}
self.stub_verifying_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_verifying_server.status = 'VERIFY_RESIZE'
self.stub_verifying_server.flavor = {'id': 8, 'ram': 768}
self.stub_server_mgr.get = MagicMock(
return_value=self.stub_verifying_server)
self.instance_task._nova_client.servers = self.stub_server_mgr
stub_flavor_manager = MagicMock(
spec=novaclient.v2.flavors.FlavorManager)
self.instance_task._nova_client.flavors = stub_flavor_manager
nova_flavor = novaclient.v2.flavors.Flavor(stub_flavor_manager,
self.new_flavor,
True)
stub_flavor_manager.get = MagicMock(return_value=nova_flavor)
self.instance_task._volume_client = MagicMock(spec=cinderclient)
self.instance_task._volume_client.volumes = Mock(
spec=cinderclient_volumes.VolumeManager)
answers = (status for status in
self.get_inst_service_status('inst_stat-id',
[ServiceStatuses.SHUTDOWN,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING]))
def side_effect_func(*args, **kwargs):
if 'instance_id' in kwargs:
return next(answers)
elif ('id' in kwargs and 'deleted' in kwargs
and not kwargs['deleted']):
return db_instance
else:
return MagicMock()
self.dbm_dbmb_patch = patch.object(
trove.db.models.DatabaseModelBase, 'find_by',
MagicMock(side_effect=side_effect_func))
self.dbm_dbmb_mock = self.dbm_dbmb_patch.start()
self.addCleanup(self.dbm_dbmb_patch.stop)
self.template_patch = patch.object(
template, 'SingleInstanceConfigTemplate',
MagicMock(spec=template.SingleInstanceConfigTemplate))
self.template_mock = self.template_patch.start()
self.addCleanup(self.template_patch.stop)
db_instance.save = MagicMock(return_value=None)
self.tbmb_running_patch = patch.object(
trove.backup.models.Backup, 'running',
MagicMock(return_value=None))
self.tbmb_running_mock = self.tbmb_running_patch.start()
self.addCleanup(self.tbmb_running_patch.stop)
if 'volume' in self._testMethodName:
self._stub_volume_client()
stub_floating_ips_manager = MagicMock(
spec=novaclient.v2.floating_ips.FloatingIPManager)
self.instance_task._nova_client.floating_ips = (
stub_floating_ips_manager)
floatingip = novaclient.v2.floating_ips.FloatingIP(
stub_floating_ips_manager, {'ip': '192.168.10.1'}, True)
stub_floating_ips_manager.list = MagicMock(return_value=[floatingip])
def setUp(self):
super(BuiltInstanceTasksTest, self).setUp()
self.new_flavor = {'id': 8, 'ram': 768, 'name': 'bigger_flavor'}
stub_nova_server = MagicMock()
rpc.get_notifier = MagicMock()
rpc.get_client = MagicMock()
db_instance = DBInstance(InstanceTasks.NONE,
id=INST_ID,
name='resize-inst-name',
datastore_version_id='1',
datastore_id='id-1',
flavor_id='6',
manager='mysql',
created=datetime.datetime.utcnow(),
updated=datetime.datetime.utcnow(),
compute_instance_id='computeinst-id-1',
tenant_id='testresize-tenant-id',
volume_size='1',
volume_id=VOLUME_ID)
# this is used during the final check of whether the resize successful
db_instance.server_status = 'ACTIVE'
self.db_instance = db_instance
datastore_models.DatastoreVersion.load_by_uuid = MagicMock(
return_value=datastore_models.DatastoreVersion(db_instance))
datastore_models.Datastore.load = MagicMock(
return_value=datastore_models.Datastore(db_instance))
self.instance_task = taskmanager_models.BuiltInstanceTasks(
trove.common.context.TroveContext(),
db_instance,
stub_nova_server,
InstanceServiceStatus(ServiceStatuses.RUNNING,
id='inst-stat-id-0'))
self.instance_task._guest = MagicMock(spec=trove.guestagent.api.API)
self.instance_task._nova_client = MagicMock(
spec=novaclient.v2.Client)
self.stub_server_mgr = MagicMock(
spec=novaclient.v2.servers.ServerManager)
self.stub_running_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_running_server.status = 'ACTIVE'
self.stub_running_server.flavor = {'id': 6, 'ram': 512}
self.stub_verifying_server = MagicMock(
spec=novaclient.v2.servers.Server)
self.stub_verifying_server.status = 'VERIFY_RESIZE'
self.stub_verifying_server.flavor = {'id': 8, 'ram': 768}
self.stub_server_mgr.get = MagicMock(
return_value=self.stub_verifying_server)
self.instance_task._nova_client.servers = self.stub_server_mgr
stub_flavor_manager = MagicMock(
spec=novaclient.v2.flavors.FlavorManager)
self.instance_task._nova_client.flavors = stub_flavor_manager
nova_flavor = novaclient.v2.flavors.Flavor(stub_flavor_manager,
self.new_flavor,
True)
stub_flavor_manager.get = MagicMock(return_value=nova_flavor)
answers = (status for status in
self.get_inst_service_status('inst_stat-id',
[ServiceStatuses.SHUTDOWN,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING,
ServiceStatuses.RUNNING]))
def side_effect_func(*args, **kwargs):
if 'instance_id' in kwargs:
return answers.next()
elif ('id' in kwargs and 'deleted' in kwargs
and not kwargs['deleted']):
return db_instance
else:
return MagicMock()
trove.db.models.DatabaseModelBase.find_by = MagicMock(
side_effect=side_effect_func)
template.SingleInstanceConfigTemplate = MagicMock(
spec=template.SingleInstanceConfigTemplate)
db_instance.save = MagicMock(return_value=None)
trove.backup.models.Backup.running = MagicMock(return_value=None)
if 'volume' in self._testMethodName:
self._stub_volume_client()
def setUp(self):
super(BuiltInstanceTasksTest, self).setUp()
self.new_flavor = {"id": 8, "ram": 768, "name": "bigger_flavor"}
stub_nova_server = MagicMock()
db_instance = DBInstance(
InstanceTasks.NONE,
id=INST_ID,
name="resize-inst-name",
datastore_version_id="1",
datastore_id="id-1",
flavor_id="6",
manager="mysql",
created=datetime.datetime.utcnow(),
updated=datetime.datetime.utcnow(),
compute_instance_id="computeinst-id-1",
tenant_id="testresize-tenant-id",
volume_size="1",
volume_id=VOLUME_ID,
)
# this is used during the final check of whether the resize successful
db_instance.server_status = "ACTIVE"
self.db_instance = db_instance
datastore_models.DatastoreVersion.load_by_uuid = MagicMock(
return_value=datastore_models.DatastoreVersion(db_instance)
)
datastore_models.Datastore.load = MagicMock(return_value=datastore_models.Datastore(db_instance))
self.instance_task = taskmanager_models.BuiltInstanceTasks(
trove.common.context.TroveContext(),
db_instance,
stub_nova_server,
InstanceServiceStatus(ServiceStatuses.RUNNING, id="inst-stat-id-0"),
)
self.instance_task._guest = MagicMock(spec=trove.guestagent.api.API)
self.instance_task._nova_client = MagicMock(spec=novaclient.v1_1.Client)
self.stub_server_mgr = MagicMock(spec=novaclient.v1_1.servers.ServerManager)
self.stub_running_server = MagicMock(spec=novaclient.v1_1.servers.Server)
self.stub_running_server.status = "ACTIVE"
self.stub_running_server.flavor = {"id": 6, "ram": 512}
self.stub_verifying_server = MagicMock(spec=novaclient.v1_1.servers.Server)
self.stub_verifying_server.status = "VERIFY_RESIZE"
self.stub_verifying_server.flavor = {"id": 8, "ram": 768}
self.stub_server_mgr.get = MagicMock(return_value=self.stub_verifying_server)
self.instance_task._nova_client.servers = self.stub_server_mgr
stub_flavor_manager = MagicMock(spec=novaclient.v1_1.flavors.FlavorManager)
self.instance_task._nova_client.flavors = stub_flavor_manager
nova_flavor = novaclient.v1_1.flavors.Flavor(stub_flavor_manager, self.new_flavor, True)
stub_flavor_manager.get = MagicMock(return_value=nova_flavor)
answers = (
status
for status in self.get_inst_service_status(
"inst_stat-id",
[ServiceStatuses.SHUTDOWN, ServiceStatuses.RUNNING, ServiceStatuses.RUNNING, ServiceStatuses.RUNNING],
)
)
def side_effect_func(*args, **kwargs):
if "instance_id" in kwargs:
return answers.next()
elif "id" in kwargs and "deleted" in kwargs and not kwargs["deleted"]:
return db_instance
else:
return MagicMock()
trove.db.models.DatabaseModelBase.find_by = MagicMock(side_effect=side_effect_func)
template.SingleInstanceConfigTemplate = MagicMock(spec=template.SingleInstanceConfigTemplate)
db_instance.save = MagicMock(return_value=None)
trove.backup.models.Backup.running = MagicMock(return_value=None)
if "volume" in self._testMethodName:
self._stub_volume_client()
class TestReplication(trove_testtools.TestCase):
def setUp(self):
util.init_db()
self.datastore = datastore_models.DBDatastore.create(
id=str(uuid.uuid4()),
name='name' + str(uuid.uuid4()),
default_version_id=str(uuid.uuid4()))
self.datastore_version = datastore_models.DBDatastoreVersion.create(
id=self.datastore.default_version_id,
name='name' + str(uuid.uuid4()),
image_id=str(uuid.uuid4()),
packages=str(uuid.uuid4()),
datastore_id=self.datastore.id,
manager='mysql',
active=1)
self.databases = []
self.users = []
self.master = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestMasterInstance",
datastore_version_id=self.datastore_version.id,
volume_size=2)
self.master.set_task_status(InstanceTasks.NONE)
self.master.save()
self.master_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=self.master.id)
self.master_status.save()
self.safe_nova_client = models.create_nova_client
models.create_nova_client = nova.fake_create_nova_client
self.swift_verify_patch = patch.object(models.Backup,
'verify_swift_auth_token')
self.addCleanup(self.swift_verify_patch.stop)
self.swift_verify_patch.start()
super(TestReplication, self).setUp()
def tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
models.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
@patch('trove.instance.models.LOG')
def test_replica_of_not_active_master(self, mock_logging):
self.master.set_task_status(InstanceTasks.BUILDING)
self.master.save()
self.master_status.set_status(ServiceStatuses.BUILDING)
self.master_status.save()
self.assertRaises(exception.UnprocessableEntity,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=self.master.id)
@patch('trove.instance.models.LOG')
def test_replica_with_invalid_slave_of_id(self, mock_logging):
self.assertRaises(exception.NotFound,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=str(uuid.uuid4()))
def test_create_replica_from_replica(self):
self.replica_datastore_version = Mock(
spec=datastore_models.DBDatastoreVersion)
self.replica_datastore_version.id = "UUID"
self.replica_datastore_version.manager = 'mysql'
self.replica_info = DBInstance(
InstanceTasks.NONE,
id="UUID",
name="TestInstance",
datastore_version_id=self.replica_datastore_version.id,
slave_of_id=self.master.id)
self.replica_info.save()
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
2,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=self.replica_info.id)
def test_create_replica_with_users(self):
self.users.append({"name": "testuser", "password": "******"})
self.assertRaises(exception.ReplicaCreateWithUsersDatabasesError,
Instance.create,
None,
'name',
2,
"UUID", [],
self.users,
self.datastore,
self.datastore_version,
1,
None,
slave_of_id=self.master.id)
def test_create_replica_with_databases(self):
self.databases.append({"name": "testdb"})
self.assertRaises(exception.ReplicaCreateWithUsersDatabasesError,
Instance.create,
None,
'name',
1,
"UUID",
self.databases, [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=self.master.id)
def test_replica_volume_size_smaller_than_master(self):
self.assertRaises(exception.Forbidden,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
1,
None,
slave_of_id=self.master.id)
def setUp(self):
super(BuiltInstanceTasksTest, self).setUp()
self.new_flavor = {"id": 8, "ram": 768, "name": "bigger_flavor"}
stub_nova_server = MagicMock()
self.rpc_patches = patch.multiple(rpc, get_notifier=MagicMock(), get_client=MagicMock())
self.rpc_mocks = self.rpc_patches.start()
self.addCleanup(self.rpc_patches.stop)
db_instance = DBInstance(
InstanceTasks.NONE,
id=INST_ID,
name="resize-inst-name",
datastore_version_id="1",
datastore_id="id-1",
flavor_id="6",
manager="mysql",
created=datetime.datetime.utcnow(),
updated=datetime.datetime.utcnow(),
compute_instance_id="computeinst-id-1",
tenant_id="testresize-tenant-id",
volume_size="1",
volume_id=VOLUME_ID,
)
# this is used during the final check of whether the resize successful
db_instance.server_status = "ACTIVE"
self.db_instance = db_instance
self.dm_dv_load_by_uuid_patch = patch.object(
datastore_models.DatastoreVersion,
"load_by_uuid",
MagicMock(return_value=datastore_models.DatastoreVersion(db_instance)),
)
self.dm_dv_load_by_uuid_mock = self.dm_dv_load_by_uuid_patch.start()
self.addCleanup(self.dm_dv_load_by_uuid_patch.stop)
self.dm_ds_load_patch = patch.object(
datastore_models.Datastore, "load", MagicMock(return_value=datastore_models.Datastore(db_instance))
)
self.dm_ds_load_mock = self.dm_ds_load_patch.start()
self.addCleanup(self.dm_ds_load_patch.stop)
self.instance_task = taskmanager_models.BuiltInstanceTasks(
trove.common.context.TroveContext(),
db_instance,
stub_nova_server,
InstanceServiceStatus(ServiceStatuses.RUNNING, id="inst-stat-id-0"),
)
self.instance_task._guest = MagicMock(spec=trove.guestagent.api.API)
self.instance_task._nova_client = MagicMock(spec=novaclient.client)
self.stub_server_mgr = MagicMock(spec=novaclient.v2.servers.ServerManager)
self.stub_running_server = MagicMock(spec=novaclient.v2.servers.Server)
self.stub_running_server.status = "ACTIVE"
self.stub_running_server.flavor = {"id": 6, "ram": 512}
self.stub_verifying_server = MagicMock(spec=novaclient.v2.servers.Server)
self.stub_verifying_server.status = "VERIFY_RESIZE"
self.stub_verifying_server.flavor = {"id": 8, "ram": 768}
self.stub_server_mgr.get = MagicMock(return_value=self.stub_verifying_server)
self.instance_task._nova_client.servers = self.stub_server_mgr
stub_flavor_manager = MagicMock(spec=novaclient.v2.flavors.FlavorManager)
self.instance_task._nova_client.flavors = stub_flavor_manager
nova_flavor = novaclient.v2.flavors.Flavor(stub_flavor_manager, self.new_flavor, True)
stub_flavor_manager.get = MagicMock(return_value=nova_flavor)
self.instance_task._volume_client = MagicMock(spec=cinderclient)
self.instance_task._volume_client.volumes = Mock(spec=cinderclient_volumes.VolumeManager)
answers = (
status
for status in self.get_inst_service_status(
"inst_stat-id",
[ServiceStatuses.SHUTDOWN, ServiceStatuses.RUNNING, ServiceStatuses.RUNNING, ServiceStatuses.RUNNING],
)
)
def side_effect_func(*args, **kwargs):
if "instance_id" in kwargs:
return answers.next()
elif "id" in kwargs and "deleted" in kwargs and not kwargs["deleted"]:
return db_instance
else:
return MagicMock()
self.dbm_dbmb_patch = patch.object(
trove.db.models.DatabaseModelBase, "find_by", MagicMock(side_effect=side_effect_func)
)
self.dbm_dbmb_mock = self.dbm_dbmb_patch.start()
self.addCleanup(self.dbm_dbmb_patch.stop)
self.template_patch = patch.object(
template, "SingleInstanceConfigTemplate", MagicMock(spec=template.SingleInstanceConfigTemplate)
)
self.template_mock = self.template_patch.start()
self.addCleanup(self.template_patch.stop)
db_instance.save = MagicMock(return_value=None)
self.tbmb_running_patch = patch.object(trove.backup.models.Backup, "running", MagicMock(return_value=None))
self.tbmb_running_mock = self.tbmb_running_patch.start()
self.addCleanup(self.tbmb_running_patch.stop)
if "volume" in self._testMethodName:
self._stub_volume_client()
stub_floating_ips_manager = MagicMock(spec=novaclient.v2.floating_ips.FloatingIPManager)
self.instance_task._nova_client.floating_ips = stub_floating_ips_manager
floatingip = novaclient.v2.floating_ips.FloatingIP(stub_floating_ips_manager, {"ip": "192.168.10.1"}, True)
stub_floating_ips_manager.list = MagicMock(return_value=[floatingip])
class TestReplication(trove_testtools.TestCase):
def setUp(self):
util.init_db()
self.datastore = datastore_models.DBDatastore.create(
id=str(uuid.uuid4()),
name='name' + str(uuid.uuid4()),
default_version_id=str(uuid.uuid4()))
self.datastore_version = datastore_models.DBDatastoreVersion.create(
id=self.datastore.default_version_id,
name='name' + str(uuid.uuid4()),
image_id=str(uuid.uuid4()),
packages=str(uuid.uuid4()),
datastore_id=self.datastore.id,
manager='mysql',
active=1)
self.databases = []
self.users = []
self.master = DBInstance(
InstanceTasks.NONE,
id=str(uuid.uuid4()),
name="TestMasterInstance",
datastore_version_id=self.datastore_version.id,
flavor_id=str(uuid.uuid4()),
volume_size=2)
self.master.set_task_status(InstanceTasks.NONE)
self.master.save()
self.master_status = InstanceServiceStatus(ServiceStatuses.RUNNING,
id=str(uuid.uuid4()),
instance_id=self.master.id)
self.master_status.save()
self.safe_nova_client = clients.create_nova_client
clients.create_nova_client = nova.fake_create_nova_client
self.swift_verify_patch = patch.object(models.Backup,
'verify_swift_auth_token')
self.addCleanup(self.swift_verify_patch.stop)
self.swift_verify_patch.start()
super(TestReplication, self).setUp()
def tearDown(self):
self.master.delete()
self.master_status.delete()
self.datastore.delete()
self.datastore_version.delete()
clients.create_nova_client = self.safe_nova_client
super(TestReplication, self).tearDown()
@patch('trove.instance.models.LOG')
def test_replica_with_invalid_slave_of_id(self, mock_logging):
self.assertRaises(exception.NotFound,
Instance.create,
None,
'name',
1,
"UUID", [], [],
self.datastore,
self.datastore_version,
2,
None,
slave_of_id=str(uuid.uuid4()))
