Python models.InstanceServiceStatus类代码示例

    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 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 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 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 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 _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 _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 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 _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 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_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