Python DBInstance.save方法代码示例

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
    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()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
 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

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
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)

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
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",
#.........这里部分代码省略.........

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
    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()
#.........这里部分代码省略.........

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
    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()

# 需要导入模块: from trove.instance.models import DBInstance [as 别名]
# 或者: from trove.instance.models.DBInstance import save [as 别名]
    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()
#.........这里部分代码省略.........