Python util.init_db函数代码示例

    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 setUp(self):
        # Basic setup and mock/fake structures for testing only
        super(TestDatastoreBase, self).setUp()
        util.init_db()
        self.rand_id = str(uuid.uuid4())
        self.ds_name = "my-test-datastore" + self.rand_id
        self.ds_version = "my-test-version" + self.rand_id
        self.capability_name = "root_on_create" + self.rand_id
        self.capability_desc = "Enables root on create"
        self.capability_enabled = True
        self.datastore_version_id = str(uuid.uuid4())
        self.flavor_id = 1

        datastore_models.update_datastore(self.ds_name, False)
        self.datastore = Datastore.load(self.ds_name)

        datastore_models.update_datastore_version(self.ds_name, self.ds_version, "mysql", "", "", True)
        DatastoreVersionMetadata.add_datastore_version_flavor_association(
            self.ds_name, self.ds_version, [self.flavor_id]
        )

        self.datastore_version = DatastoreVersion.load(self.datastore, self.ds_version)
        self.test_id = self.datastore_version.id

        self.cap1 = Capability.create(self.capability_name, self.capability_desc, True)
        self.cap2 = Capability.create("require_volume" + self.rand_id, "Require external volume", True)
        self.cap3 = Capability.create("test_capability" + self.rand_id, "Test capability", False)

    def setUp(self):
        self.context = trove_testtools.TroveTestContext(self, is_admin=True)
        util.init_db()

        self.datastore = datastore_models.DBDatastore.create(
            id=str(uuid.uuid4()),
            name='test' + str(uuid.uuid4()),
            default_version_id=str(uuid.uuid4()))

        self.datastore_version1 = datastore_models.DBDatastoreVersion.create(
            id=self.datastore.default_version_id,
            name='name' + str(uuid.uuid4()),
            image_id='old_image',
            packages=str(uuid.uuid4()),
            datastore_id=self.datastore.id,
            manager='test',
            active=1)

        self.datastore_version2 = datastore_models.DBDatastoreVersion.create(
            id=str(uuid.uuid4()),
            name='name' + str(uuid.uuid4()),
            image_id='new_image',
            packages=str(uuid.uuid4()),
            datastore_id=self.datastore.id,
            manager='test',
            active=1)

        self.safe_nova_client = models.create_nova_client
        models.create_nova_client = nova.fake_create_nova_client
        super(TestInstanceUpgrade, self).setUp()

 def setUp(self):
     # See LP bug #1255178
     bkup_models.DBBackup.save = OLD_DBB_SAVE
     super(ConductorMethodTests, self).setUp()
     util.init_db()
     self.cond_mgr = conductor_manager.Manager()
     self.instance_id = utils.generate_uuid()

 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 setUp(self):
     util.init_db()
     self.fake_tenantid = 'fake_fore_1231242345'
     self.fake_context = fake()
     self.fake_context.limit = 1000
     self.fake_context.is_admin = False
     self.fake_context.marker = None
     self.fake_context['tenant'] = self.fake_tenantid 
     self.fake_environ = {wsgi.CONTEXT_KEY : self.fake_context}
     self.fake_request = fake()
     self.fake_request.url = "http://fore.com/***"
     self.fake_request.environ = self.fake_environ
     
     self.cnf_controller = conf_service.ConfigurationsController()
     self.para_controller = conf_service.ParametersController()
     self.base_body = {
                         "configuration": {
                             "values": {},
                             "name": "test",
                             "description":"desc....",
                             "datastore": {
                                 "type": "test_type",
                                 "version": "test_version"
                             }
                         }
                       }
     
     self.fake_dsname = "test_type"
     self.fake_dsversion = "test_version"
     ds_models.update_datastore(self.fake_dsname)
     ds = ds_models.Datastore.load(self.fake_dsname)
     ds_models.update_datastore_version(ds.name, self.fake_dsversion, "mysql", "None","None", '1','1')

 def setUp(self):
     super(OrderingTests, self).setUp()
     util.init_db()
     now = utils.utcnow()
     self.context, self.instance_id = _prep_conf(now)
     info = {
         'tenant_id': self.context.tenant,
         'state': BACKUP_STATE,
         'instance_id': self.instance_id,
         'size': 2.0,
         'deleted': False
     }
     four = now - datetime.timedelta(days=4)
     one = now - datetime.timedelta(days=1)
     three = now - datetime.timedelta(days=3)
     two = now - datetime.timedelta(days=2)
     # Create backups out of order, save/create set the 'updated' field,
     # so we need to use the db_api directly.
     models.DBBackup().db_api.save(
         models.DBBackup(name='four', updated=four,
                         id=utils.generate_uuid(), **info))
     models.DBBackup().db_api.save(
         models.DBBackup(name='one', updated=one,
                         id=utils.generate_uuid(), **info))
     models.DBBackup().db_api.save(
         models.DBBackup(name='three', updated=three,
                         id=utils.generate_uuid(), **info))
     models.DBBackup().db_api.save(
         models.DBBackup(name='two', updated=two,
                         id=utils.generate_uuid(), **info))

 def setUp(self):
     super(TemplateTest, self).setUp()
     util.init_db()
     self.env = template.ENV
     self.template = self.env.get_template("mysql/config.template")
     self.flavor_dict = {"ram": 1024, "name": "small", "id": "55"}
     self.server_id = "180b5ed1-3e57-4459-b7a3-2aeee4ac012a"

    def setUp(self):
        util.init_db()
        self.context = Mock()
        self.name = "name"
        self.module_type = 'ping'
        self.contents = 'my_contents\n'

        super(CreateModuleTest, self).setUp()

    def setUpClass(cls):
        util.init_db()
        # put some fake datastore versions into the usage_report DSV cache
        # so that we don't read all the DSVs from the test database
        usage_report.DSVS = list()
        for dsv in DS_VERSIONS:
            usage_report.DSVS.append(MockDSVersion(dsv[0], dsv[1], dsv[2]))

        super(UsageReportTest, cls).setUpClass()

 def setUp(self):
     super(PXCClusterTasksTest, self).setUp()
     util.init_db()
     self.cluster_id = "1232"
     self.cluster_name = "Cluster-1234"
     self.tenant_id = "6789"
     self.db_cluster = DBCluster(ClusterTaskStatus.NONE,
                                 id=self.cluster_id,
                                 created=str(datetime.date),
                                 updated=str(datetime.date),
                                 name=self.cluster_name,
                                 task_id=ClusterTaskStatus.NONE._code,
                                 tenant_id=self.tenant_id,
                                 datastore_version_id="1",
                                 deleted=False)
     self.dbinst1 = DBInstance(InstanceTasks.NONE, id="1", name="member1",
                               compute_instance_id="compute-1",
                               task_id=InstanceTasks.NONE._code,
                               task_description=InstanceTasks.NONE._db_text,
                               volume_id="volume-1",
                               datastore_version_id="1",
                               cluster_id=self.cluster_id,
                               type="member")
     self.dbinst2 = DBInstance(InstanceTasks.NONE, id="2", name="member2",
                               compute_instance_id="compute-2",
                               task_id=InstanceTasks.NONE._code,
                               task_description=InstanceTasks.NONE._db_text,
                               volume_id="volume-2",
                               datastore_version_id="1",
                               cluster_id=self.cluster_id,
                               type="member")
     self.dbinst3 = DBInstance(InstanceTasks.NONE, id="3", name="member3",
                               compute_instance_id="compute-3",
                               task_id=InstanceTasks.NONE._code,
                               task_description=InstanceTasks.NONE._db_text,
                               volume_id="volume-3",
                               datastore_version_id="1",
                               cluster_id=self.cluster_id,
                               type="member")
     mock_ds1 = Mock()
     mock_ds1.name = 'pxc'
     mock_dv1 = Mock()
     mock_dv1.name = '7.1'
     self.clustertasks = ClusterTasks(Mock(),
                                      self.db_cluster,
                                      datastore=mock_ds1,
                                      datastore_version=mock_dv1)
     self.cluster_context = {
         'replication_user': {
             'name': "name",
             'password': "password",
         },
         'cluster_name': self.cluster_name,
         'admin_password': "admin_password"
     }

 def setUp(self):
     super(BackupORMTest, self).setUp()
     util.init_db()
     self.context, self.instance_id = _prep_conf(utils.utcnow())
     self.backup = models.DBBackup.create(tenant_id=self.context.tenant,
                                          name=BACKUP_NAME,
                                          state=BACKUP_STATE,
                                          instance_id=self.instance_id,
                                          deleted=False,
                                          location=BACKUP_LOCATION)
     self.deleted = False

 def setUp(self):
     super(PaginationTests, self).setUp()
     util.init_db()
     self.context, self.instance_id = _prep_conf(utils.utcnow())
     # Create a bunch of backups
     bkup_info = {
         "tenant_id": self.context.tenant,
         "state": BACKUP_STATE,
         "instance_id": self.instance_id,
         "size": 2.0,
         "deleted": False,
     }
     for backup in xrange(50):
         bkup_info.update({"name": "Backup-%s" % backup})
         models.DBBackup.create(**bkup_info)

 def setUpClass(cls):
     util.init_db()
     cls.version_id = str(uuid.uuid4())
     cls.datastore = datastore_models.DBDatastore.create(
         id=str(uuid.uuid4()),
         name='mysql' + str(uuid.uuid4()),
         default_version_id=cls.version_id
     )
     cls.version = datastore_models.DBDatastoreVersion.create(
         id=cls.version_id,
         datastore_id=cls.datastore.id,
         name='5.5' + str(uuid.uuid4()),
         manager='mysql',
         image_id=str(uuid.uuid4()),
         active=1,
         packages="mysql-server-5.5"
     )
     super(MockMgmtInstanceTest, cls).setUpClass()

 def setUp(self):
     util.init_db()
     
     ds_models.update_datastore("mysql")
     self.datastore = ds_models.Datastore.load("mysql")
     
     ds_models.update_datastore_version(self.datastore.id, "mysql-55", "mysql", "None", "None", True) 
     self.ds_version = ds_models.DatastoreVersion.load(self.datastore, "mysql-55")
     
     test_time = utils.utcnow()
     self.conf_name = "test_name_%s " %test_time
     self.conf_desc = "test_desc_%s " %test_time
     self.configuration = None
     self.defaultConfiguration = None
     
     self.tanant_id = "fake_fore_1231242345"
     self.context = TroveContext(tenant = self.tanant_id)
     self.default_tanant_id = CONF.default_template_tenant_id