def get_inst_service_status(self, status_id, statuses): answers = [] for i, status in enumerate(statuses): inst_svc_status = InstanceServiceStatus(status, id="%s-%s" % (status_id, i)) inst_svc_status.save = MagicMock(return_value=None) answers.append(inst_svc_status) return answers
def setUp(self): super(BaseDbStatusTest, self).setUp() util.init_db() self.orig_dbaas_time_sleep = dbaas.time.sleep self.FAKE_ID = randint(1, 10000) InstanceServiceStatus.create(instance_id=self.FAKE_ID, status=rd_instance.ServiceStatuses.NEW) dbaas.CONF.guest_id = self.FAKE_ID
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 tearDown(self): super(MySqlAppStatusTest, self).tearDown() dbaas.utils.execute_with_timeout = self.orig_utils_execute_with_timeout dbaas.load_mysqld_options = self.orig_load_mysqld_options dbaas.os.path.exists = self.orig_dbaas_os_path_exists dbaas.time.sleep = self.orig_dbaas_time_sleep InstanceServiceStatus.find_by(instance_id=self.FAKE_ID).delete() dbaas.CONF.guest_id = None
def setUp(self): super(MySqlAppTest, self).setUp() self.orig_utils_execute_with_timeout = dbaas.utils.execute_with_timeout self.orig_time_sleep = time.sleep util.init_db() self.FAKE_ID = randint(1, 10000) InstanceServiceStatus.create(instance_id=self.FAKE_ID, status=rd_instance.ServiceStatuses.NEW) self.appStatus = FakeAppStatus(self.FAKE_ID, rd_instance.ServiceStatuses.NEW) self.mySqlApp = MySqlApp(self.appStatus) time.sleep = Mock()
def setUp(self): super(MySqlAppStatusTest, self).setUp() util.init_db() self.orig_utils_execute_with_timeout = dbaas.utils.execute_with_timeout self.orig_load_mysqld_options = dbaas.load_mysqld_options self.orig_dbaas_os_path_exists = dbaas.os.path.exists self.orig_dbaas_time_sleep = dbaas.time.sleep self.FAKE_ID = randint(1, 10000) InstanceServiceStatus.create(instance_id=self.FAKE_ID, status=rd_instance.ServiceStatuses.NEW) dbaas.CONF.guest_id = self.FAKE_ID
def update_statuses_on_time_out(self): if CONF.update_status_on_fail: #Updating service status service = InstanceServiceStatus.find_by(instance_id=self.id) service.set_status(ServiceStatuses. FAILED_TIMEOUT_GUESTAGENT) service.save() LOG.error(_("Service status: %(status)s") % {'status': ServiceStatuses. FAILED_TIMEOUT_GUESTAGENT.api_status}) LOG.error(_("Service error description: %(desc)s") % {'desc': ServiceStatuses. FAILED_TIMEOUT_GUESTAGENT.description}) #Updating instance status db_info = DBInstance.find_by(name=self.name) db_info.set_task_status(InstanceTasks. BUILDING_ERROR_TIMEOUT_GA) db_info.save() LOG.error(_("Trove instance status: %(action)s") % {'action': InstanceTasks. BUILDING_ERROR_TIMEOUT_GA.action}) LOG.error(_("Trove instance status description: %(text)s") % {'text': InstanceTasks. BUILDING_ERROR_TIMEOUT_GA.db_text})
def monitor_ha(self, context): """Monitors the status of MySQL masters to make sure they are up.""" LOG.debug("Monitoring Trove Replica Sources (Masters)") db_infos = t_models.DBInstance.find_all(deleted=False) masters_to_watch = [(instance.slave_of_id, instance) for instance in db_infos.all() if instance.slave_of_id and instance.task_status == InstanceTasks.NONE] LOG.debug("Monitoring %s", masters_to_watch) for (master_id, slave) in masters_to_watch: master = t_models.DBInstance.find_by(deleted=False, id=master_id) service = InstanceServiceStatus.find_by(instance_id=master_id) if self._engage_failover(service): LOG.debug("Engage FAILOVER from %s to %s NOW!", master_id, slave.id) master = t_models.DBInstance.find_by(id=master_id, deleted=False) self._create_and_auth_clients() # Failover Slave to Master by detaching replica source on slave self.trove_client.instances.edit(slave.id, detach_replica_source=True) # Update DNS records for master and slave master_dns, slave_dns = self._update_dns_records(master, slave) # Finally update the hostnames in trove to # reflect the updated DNS information self._reflect_dns_updates_in_trove(master, master_dns, slave, slave_dns)
def _init(self): self.mock = mox.Mox() self.instance_id = 500 context = trove_testtools.TroveTestContext(self) self.db_info = DBInstance.create( name="instance", flavor_id=OLD_FLAVOR_ID, tenant_id=999, volume_size=None, datastore_version_id=test_config.dbaas_datastore_version_id, task_status=InstanceTasks.RESIZING) self.server = self.mock.CreateMock(Server) self.instance = models.BuiltInstanceTasks( context, self.db_info, self.server, datastore_status=InstanceServiceStatus.create( instance_id=self.db_info.id, status=rd_instance.ServiceStatuses.RUNNING)) self.instance.server.flavor = {'id': OLD_FLAVOR_ID} self.guest = self.mock.CreateMock(guest.API) self.instance._guest = self.guest self.instance.refresh_compute_server_info = lambda: None self.instance._refresh_datastore_status = lambda: None self.mock.StubOutWithMock(self.instance, 'update_db') self.mock.StubOutWithMock(self.instance, 'set_datastore_status_to_paused') self.poll_until_mocked = False self.action = None
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 _service_is_active(self): """ Check that the database guest is active. This function is meant to be called with poll_until to check that the guest is alive before sending a 'create' message. This prevents over billing a customer for a instance that they can never use. Returns: boolean if the service is active. Raises: TroveError if the service is in a failure state. """ service = InstanceServiceStatus.find_by(instance_id=self.id) status = service.get_status() if status == rd_instance.ServiceStatuses.RUNNING: return True elif status not in [rd_instance.ServiceStatuses.NEW, rd_instance.ServiceStatuses.BUILDING]: raise TroveError(_("Service not active, status: %s") % status) c_id = self.db_info.compute_instance_id nova_status = self.nova_client.servers.get(c_id).status if nova_status in [InstanceStatus.ERROR, InstanceStatus.FAILED]: raise TroveError(_("Server not active, status: %s") % nova_status) return False
def update_db(): status = InstanceServiceStatus.find_by(instance_id=self.id) if instance_name.endswith('GUEST_ERROR'): status.status = rd_instance.ServiceStatuses.FAILED else: status.status = rd_instance.ServiceStatuses.RUNNING status.save() AgentHeartBeat.create(instance_id=self.id)
def _set_status(self, new_status="RUNNING"): from trove.instance.models import InstanceServiceStatus print("Setting status to %s" % new_status) states = {"RUNNING": rd_instance.ServiceStatuses.RUNNING, "SHUTDOWN": rd_instance.ServiceStatuses.SHUTDOWN} status = InstanceServiceStatus.find_by(instance_id=self.id) status.status = states[new_status] status.save()
def _set_task_status(self, new_status='RUNNING'): from trove.instance.models import InstanceServiceStatus print("Setting status to %s" % new_status) states = {'RUNNING': rd_instance.ServiceStatuses.RUNNING, 'SHUTDOWN': rd_instance.ServiceStatuses.SHUTDOWN, } status = InstanceServiceStatus.find_by(instance_id=self.id) status.status = states[new_status] status.save()
def setUp(self): super(MySqlAppTest, self).setUp() self.orig_utils_execute_with_timeout = dbaas.utils.execute_with_timeout self.orig_time_sleep = dbaas.time.sleep util.init_db() self.FAKE_ID = randint(1, 10000) InstanceServiceStatus.create(instance_id=self.FAKE_ID, status=rd_instance.ServiceStatuses.NEW) self.appStatus = FakeAppStatus(self.FAKE_ID, rd_instance.ServiceStatuses.NEW) self.mySqlApp = MySqlApp(self.appStatus) mysql_service = {'cmd_start': Mock(), 'cmd_stop': Mock(), 'cmd_enable': Mock(), 'cmd_disable': Mock(), 'bin': Mock()} dbaas.operating_system.service_discovery = Mock(return_value= mysql_service) dbaas.time.sleep = Mock()
def __call__(self): audit_start, audit_end = NotificationTransformer._get_audit_period() messages = [] db_infos = instance_models.DBInstance.find_all(deleted=False) for db_info in db_infos: service_status = InstanceServiceStatus.find_by( instance_id=db_info.id) instance = SimpleMgmtInstance(None, db_info, None, service_status) message = self.transform_instance(instance, audit_start, audit_end) messages.append(message) return messages
def _instance_ids_with_failures(ids): LOG.debug("Checking for service status failures for " "instance ids: %s" % ids) failed_instance_ids = [] for instance_id in ids: status = InstanceServiceStatus.find_by( instance_id=instance_id).get_status() if (status == ServiceStatuses.FAILED or status == ServiceStatuses.FAILED_TIMEOUT_GUESTAGENT): failed_instance_ids.append(instance_id) return failed_instance_ids
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 test_add_query_routers_new_cluster(self, mock_dv, mock_ds, mock_password, mock_guest): query_router = BaseInstance(Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) mock_password.return_value = 'pwd' ret_val = self.clustertasks._add_query_routers([query_router], ['10.0.0.5'], new_cluster=True) mock_guest.assert_called_with(query_router) mock_guest().add_config_servers.assert_called_with(['10.0.0.5']) mock_guest().create_admin_user.assert_called_with('pwd') self.assertEqual(True, ret_val)
def test_create_shard_failure(self, mock_dv, mock_ds, mock_ip, mock_guest, mock_init_rs, mock_update): member1 = BaseInstance(Mock(), self.dbinst1, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) member2 = BaseInstance(Mock(), self.dbinst2, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) members = [member1, member2] mock_ip.side_effect = ["10.0.0.2"] query_router = [ BaseInstance(Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) ] mock_guest().get_replica_set_name.return_value = 'testrs' mock_add_shard = Mock(side_effect=Exception("Boom!")) mock_guest().add_shard = mock_add_shard ret_val = self.clustertasks._create_shard(query_router, members) mock_init_rs.assert_called_with(member1, [member2]) mock_update.assert_called_with(self.cluster_id, shard_id="shard-1") self.assertEqual(False, ret_val)
def setUp(self): super(SimpleInstanceTest, self).setUp() db_info = DBInstance(InstanceTasks.BUILDING, name="TestInstance") self.instance = SimpleInstance(None, db_info, InstanceServiceStatus( ServiceStatuses.BUILDING), ds_version=Mock(), ds=Mock()) db_info.addresses = {"private": [{"addr": "123.123.123.123"}], "internal": [{"addr": "10.123.123.123"}], "public": [{"addr": "15.123.123.123"}]} self.orig_conf = CONF.network_label_regex self.orig_ip_regex = CONF.ip_regex self.orig_black_list_regex = CONF.black_list_regex
def test_create_cluster(self, mock_dv, mock_ds, mock_find_all, mock_load, mock_ready, mock_ip, mock_guest, mock_reset_task): mock_find_all.return_value.all.return_value = [self.dbinst1] mock_load.return_value = BaseInstance(Mock(), self.dbinst1, Mock(), InstanceServiceStatus( ServiceStatuses.NEW)) mock_ip.return_value = "10.0.0.2" self.clustertasks.create_cluster(Mock(), self.cluster_id) mock_guest.return_value.install_cluster.assert_called_with(['10.0.0.2'] ) mock_reset_task.assert_called() mock_guest.return_value.cluster_complete.assert_called()
def test_create_shard(self, mock_dv, mock_ds, mock_ip, mock_guest, mock_init_rs): member1 = BaseInstance(Mock(), self.dbinst1, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) member2 = BaseInstance(Mock(), self.dbinst2, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) members = [member1, member2] mock_ip.side_effect = ["10.0.0.2"] query_router = [ BaseInstance(Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) ] mock_guest().get_replica_set_name.return_value = 'testrs' mock_add_shard = Mock() mock_guest().add_shard = mock_add_shard ret_val = self.clustertasks._create_shard(query_router, members) mock_init_rs.assert_called_with(member1, [member2]) mock_add_shard.assert_called_with("testrs", "10.0.0.2") self.assertEqual(True, ret_val)
def test_add_query_routers_failure(self, mock_logging, mock_dv, mock_ds, mock_password, mock_guest, mock_update): query_router = BaseInstance( Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW) ) mock_guest.side_effect = Exception("Boom!") ret_val = self.clustertasks._add_query_routers([query_router], ['10.0.0.5']) mock_update.assert_called_with(self.cluster_id) self.assertFalse(ret_val)
def test_create_shard_failure(self, mock_dv, mock_ds, mock_ip, mock_guest, mock_update): member1 = BaseInstance(Mock(), self.dbinst1, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) member2 = BaseInstance(Mock(), self.dbinst2, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) members = [member1, member2] query_routers = [ BaseInstance(Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) ] mock_ip.return_value = "10.0.0.2" mock_guest.return_value.add_shard = Mock( side_effect=Exception("Boom!")) ret_val = self.clustertasks._create_shard(query_routers, "rs1", members, self.cluster_id, shard_id="shard-1") mock_guest.return_value.add_shard.assert_called_with("rs1", "10.0.0.2") mock_update.assert_called_with(self.cluster_id, "shard-1") self.assertEqual(False, ret_val)
def test_grow_cluster_query_router(self, mock_dv, mock_ds, mock_load, mock_ip, mock_add_query_router): query_router = BaseInstance( Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW) ) config_server = BaseInstance( Mock(), self.dbinst4, Mock(), InstanceServiceStatus(ServiceStatuses.NEW) ) mock_load.side_effect = [query_router, config_server] mock_ip.return_value = '10.0.0.5' mock_add_query_router.return_value = True self._run_grow_cluster(new_instances_ids=[query_router.id]) mock_add_query_router.assert_called_with( [query_router], ['10.0.0.5'] )
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
def test_grow_cluster_shard(self, mock_dv, mock_ds, mock_running_qr_id, mock_load, mock_create_shard): mock_running_qr_id.return_value = '3' member1 = BaseInstance(Mock(), self.dbinst1, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) member2 = BaseInstance(Mock(), self.dbinst2, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) query_router = BaseInstance( Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW) ) mock_load.side_effect = [member1, member2, query_router] mock_create_shard.return_value = True self._run_grow_cluster(new_instances_ids=[member1.id, member2.id]) mock_create_shard.assert_called_with( query_router, [member1, member2] )
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 super(TestReplication, self).setUp()
def test_create_cluster_fail(self, mock_logging, mock_dv, mock_ds, mock_find_all, mock_load, mock_ready, mock_ip, mock_reset_task, mock_update_status): mock_find_all.return_value.all.return_value = [self.dbinst1] mock_load.return_value = BaseInstance( Mock(), self.dbinst1, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) mock_ip.return_value = "10.0.0.2" guest_client = Mock() guest_client.install_cluster = Mock(side_effect=GuestError("Error")) with patch.object(ClusterTasks, 'get_guest', return_value=guest_client): self.clustertasks.create_cluster(Mock(), self.cluster_id) mock_update_status.assert_called_with('1232') mock_reset_task.assert_called_with()
def setUp(self): super(SimpleInstanceTest, self).setUp() self.context = trove_testtools.TroveTestContext(self, is_admin=True) db_info = DBInstance( InstanceTasks.BUILDING, name="TestInstance") self.instance = SimpleInstance( None, db_info, InstanceServiceStatus( ServiceStatuses.BUILDING), ds_version=Mock(), ds=Mock(), locality='affinity') self.instance.context = self.context db_info.addresses = {"private": [{"addr": "123.123.123.123"}], "internal": [{"addr": "10.123.123.123"}], "public": [{"addr": "15.123.123.123"}]} self.orig_conf = CONF.network_label_regex self.orig_ip_regex = CONF.ip_regex self.orig_black_list_regex = CONF.black_list_regex
def test_add_shard_cluster(self, mock_find_all, mock_all_instances_ready, mock_load, mock_dv, mock_ds, mock_add_shard, mock_guest, mock_reset_task): mock_find_all.return_value.all.return_value = [ self.dbinst1, self.dbinst2, self.dbinst3, self.dbinst4 ] mock_load.return_value = BaseInstance( Mock(), self.dbinst1, Mock(), InstanceServiceStatus(ServiceStatuses.NEW)) mock_all_instances_ready.return_value = True mock_add_shard.return_value = True mock_guest.return_value.cluster_complete.return_value = Mock() self.clustertasks.add_shard_cluster(Mock(), self.cluster_id, "shard-1", "rs1") mock_guest.return_value.cluster_complete.assert_called_with() mock_reset_task.assert_called_with()
def setUp(self): util.init_db() self.db_info = FakeDBInstance() self.status = InstanceServiceStatus(ServiceStatuses.RUNNING) self.datastore = models.DBDatastore.create( id=str(uuid.uuid4()), name='mysql' + str(uuid.uuid4()), default_version_id=self.db_info.datastore_version_id) self.version = models.DBDatastoreVersion.create( id=self.db_info.datastore_version_id, datastore_id=self.datastore.id, name='5.7' + str(uuid.uuid4()), manager='mysql', image_id=str(uuid.uuid4()), active=1, packages="mysql-server-5.7") super(BaseInstanceStatusTestCase, self).setUp()
def test_add_query_routers(self, mock_dv, mock_ds, mock_guest): password = '******' query_router = BaseInstance( Mock(), self.dbinst3, Mock(), InstanceServiceStatus(ServiceStatuses.NEW) ) ret_val = self.clustertasks._add_query_routers([query_router], ['10.0.0.5'], admin_password=password) mock_guest.assert_called_with(query_router) mock_guest().add_config_servers.assert_called_with(['10.0.0.5']) mock_guest().store_admin_password.assert_called_with(password) self.assertTrue(ret_val)
def test_tranformer(self): transformer = mgmtmodels.NotificationTransformer(context=self.context) status = rd_instance.ServiceStatuses.BUILDING.api_status db_instance = MockMgmtInstanceTest.build_db_instance( status, InstanceTasks.BUILDING) when(DatabaseModelBase).find_all(deleted=False).thenReturn( [db_instance]) when(DatabaseModelBase).find_by(instance_id='1').thenReturn( InstanceServiceStatus(rd_instance.ServiceStatuses.BUILDING)) payloads = transformer() self.assertIsNotNone(payloads) self.assertThat(len(payloads), Equals(1)) payload = payloads[0] self.assertThat(payload['audit_period_beginning'], Not(Is(None))) self.assertThat(payload['audit_period_ending'], Not(Is(None))) self.assertThat(payload['state'], Equals(status.lower()))
def __call__(self): audit_start, audit_end = NotificationTransformer._get_audit_period() messages = [] db_infos = instance_models.DBInstance.find_all(deleted=False) for db_info in db_infos: try: service_status = InstanceServiceStatus.find_by(instance_id=db_info.id) except exception.ModelNotFoundError: # There is a small window of opportunity during when the db # resource for an instance exists, but no InstanceServiceStatus # for it has yet been created. We skip sending the notification # message for all such instances. These instance are too new # and will get picked up the next round of notifications. LOG.debug("InstanceServiceStatus not found for %s. " "Will wait to send notification." % db_info.id) continue instance = SimpleMgmtInstance(None, db_info, None, service_status) message = self.transform_instance(instance, audit_start, audit_end) messages.append(message) return messages
def _all_status_ready(ids): LOG.debug("Checking service status of instance ids: %s" % ids) for instance_id in ids: status = InstanceServiceStatus.find_by( instance_id=instance_id).get_status() if (status == ServiceStatuses.FAILED or status == ServiceStatuses.FAILED_TIMEOUT_GUESTAGENT): # if one has failed, no need to continue polling LOG.debug("Instance %s in %s, exiting polling." % ( instance_id, status)) return True if (status != ServiceStatuses.RUNNING and status != ServiceStatuses.BUILD_PENDING): # if one is not in a ready state, continue polling LOG.debug("Instance %s in %s, continue polling." % ( instance_id, status)) return False LOG.debug("Instances are ready, exiting polling for: %s" % ids) return True
def _all_status_ready(ids): LOG.debug("Checking service status of instance ids: %s" % ids) for instance_id in ids: status = InstanceServiceStatus.find_by( instance_id=instance_id).get_status() if (status == ServiceStatuses.FAILED or status == ServiceStatuses.FAILED_TIMEOUT_GUESTAGENT): # if one has failed, no need to continue polling LOG.debug("Instance %s in %s, exiting polling." % (instance_id, status)) return True if (status != ServiceStatuses.RUNNING and status != ServiceStatuses.BUILD_PENDING): # if one is not in a ready state, continue polling LOG.debug("Instance %s in %s, continue polling." % (instance_id, status)) return False LOG.debug("Instances are ready, exiting polling for: %s" % ids) return True
def __init__(self, host_info): self.name = host_info.name self.percent_used = host_info.percentUsed self.total_ram = host_info.totalRAM self.used_ram = host_info.usedRAM self.instances = host_info.instances for instance in self.instances: instance["server_id"] = instance["uuid"] del instance["uuid"] try: db_info = DBInstance.find_by(compute_instance_id=instance["server_id"]) instance["id"] = db_info.id instance["tenant_id"] = db_info.tenant_id status = InstanceServiceStatus.find_by(instance_id=db_info.id) instance_info = SimpleInstance(None, db_info, status) instance["status"] = instance_info.status except exception.TroveError as re: LOG.error(re) LOG.error("Compute Instance ID found with no associated RD " "instance: %s" % instance["server_id"]) instance["id"] = None
def __call__(self): audit_start, audit_end = NotificationTransformer._get_audit_period() messages = [] db_infos = instance_models.DBInstance.find_all(deleted=False) for db_info in db_infos: try: service_status = InstanceServiceStatus.find_by( instance_id=db_info.id) except exception.ModelNotFoundError: # There is a small window of opportunity during when the db # resource for an instance exists, but no InstanceServiceStatus # for it has yet been created. We skip sending the notification # message for all such instances. These instance are too new # and will get picked up the next round of notifications. LOG.debug("InstanceServiceStatus not found for %s. " "Will wait to send notification." % db_info.id) continue instance = SimpleMgmtInstance(None, db_info, None, service_status) message = self.transform_instance(instance, audit_start, audit_end) messages.append(message) return messages
def __init__(self, host_info): self.name = host_info.name self.percent_used = host_info.percentUsed self.total_ram = host_info.totalRAM self.used_ram = host_info.usedRAM self.instances = host_info.instances for instance in self.instances: instance['server_id'] = instance['uuid'] del instance['uuid'] try: db_info = DBInstance.find_by( compute_instance_id=instance['server_id']) instance['id'] = db_info.id instance['tenant_id'] = db_info.tenant_id status = InstanceServiceStatus.find_by(instance_id=db_info.id) instance_info = SimpleInstance(None, db_info, status) instance['status'] = instance_info.status except exception.TroveError as re: LOG.error(re) LOG.error("Compute Instance ID found with no associated RD " "instance: %s" % instance['server_id']) instance['id'] = None
def _service_is_active(self): """ Check that the database guest is active. This function is meant to be called with poll_until to check that the guest is alive before sending a 'create' message. This prevents over billing a customer for a instance that they can never use. Returns: boolean if the service is active. Raises: TroveError if the service is in a failure state. """ service = InstanceServiceStatus.find_by(instance_id=self.id) status = service.get_status() if status == ServiceStatuses.RUNNING: return True elif status not in [ServiceStatuses.NEW, ServiceStatuses.BUILDING]: raise TroveError("Service not active, status: %s" % status) c_id = self.db_info.compute_instance_id nova_status = self.nova_client.servers.get(c_id).status if nova_status in [InstanceStatus.ERROR, InstanceStatus.FAILED]: raise TroveError("Server not active, status: %s" % nova_status) return False
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)
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): self.db_info.task_status = FakeInstanceTask() self.db_info.server_status = "ACTIVE" self.ds_status = InstanceServiceStatus(ServiceStatuses.HEALTHY) super(InstanceStatusTest, self).setUp()
def _create(self,group_id,type): id = self.instance_id InstanceServiceStatus.create(status=ServiceStatuses.RUNNING,instance_id=id) return InstanceGroupItem.create(self.context,self.tenant_id,id,group_id,type)
def tearDown(self): super(MySqlAppTest, self).tearDown() dbaas.utils.execute_with_timeout = self.orig_utils_execute_with_timeout time.sleep = self.orig_time_sleep InstanceServiceStatus.find_by(instance_id=self.FAKE_ID).delete()
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 set_server_running(): instance = DBInstance.find_by(compute_instance_id=id) LOG.debug("Setting server %s to running" % instance.id) status = InstanceServiceStatus.find_by(instance_id=instance.id) status.status = rd_instance.ServiceStatuses.RUNNING status.save()
def _set_service_status_to_paused(self): status = InstanceServiceStatus.find_by(instance_id=self.id) status.set_status(inst_models.ServiceStatuses.PAUSED) status.save()
def _refresh_compute_service_status(self): """Refreshes the service status info for an instance.""" service = InstanceServiceStatus.find_by(instance_id=self.id) self.service_status = service.get_status()
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 assert_reported_status(self, expected_status): service_status = InstanceServiceStatus.find_by( instance_id=self.FAKE_ID) self.assertEqual(expected_status, service_status.status)
def _load_status(self): return InstanceServiceStatus.find_by(instance_id=self.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 _set_service_status_to_paused(self): status = InstanceServiceStatus.find_by(instance_id=self.id) status.set_status(rd_instance.ServiceStatuses.PAUSED) status.save()
def tearDown(self): super(BaseDbStatusTest, self).tearDown() dbaas.time.sleep = self.orig_dbaas_time_sleep InstanceServiceStatus.find_by(instance_id=self.FAKE_ID).delete() dbaas.CONF.guest_id = None