Python db.constraint函数代码示例

    def test_delete_fast_if_host_not_set(self):
        inst = self._create_instance_obj()
        inst.host = ''
        updates = {'progress': 0, 'task_state': task_states.DELETING}

        self.mox.StubOutWithMock(inst, 'save')
        self.mox.StubOutWithMock(db,
                                 'block_device_mapping_get_all_by_instance')

        self.mox.StubOutWithMock(db, 'constraint')
        self.mox.StubOutWithMock(db, 'instance_destroy')
        self.mox.StubOutWithMock(self.compute_api, '_create_reservations')

        db.block_device_mapping_get_all_by_instance(self.context,
                                                    inst.uuid).AndReturn([])
        inst.save()
        self.compute_api._create_reservations(self.context,
                                              inst, inst.instance_type_id,
                                              inst.project_id, inst.user_id
                                              ).AndReturn(None)
        db.constraint(host=mox.IgnoreArg()).AndReturn('constraint')
        db.instance_destroy(self.context, inst.uuid, 'constraint')

        self.mox.ReplayAll()

        self.compute_api.delete(self.context, inst)
        for k, v in updates.items():
            self.assertEqual(inst[k], v)

    def test_delete_fast_if_host_not_set(self):
        inst = self._create_instance_obj()
        inst.host = ''
        db_inst = obj_base.obj_to_primitive(inst)
        updates = {'progress': 0, 'task_state': task_states.DELETING}
        new_inst = dict(db_inst, **updates)

        self.mox.StubOutWithMock(db,
                                 'block_device_mapping_get_all_by_instance')
        self.mox.StubOutWithMock(db,
                                 'instance_update_and_get_original')
        self.mox.StubOutWithMock(db, 'constraint')
        self.mox.StubOutWithMock(db, 'instance_destroy')
        self.mox.StubOutWithMock(self.compute_api, '_create_reservations')

        db.block_device_mapping_get_all_by_instance(self.context,
                                                    inst.uuid).AndReturn([])
        db.instance_update_and_get_original(
            self.context, inst.uuid, updates).AndReturn((db_inst, new_inst))
        self.compute_api._create_reservations(self.context,
                                              db_inst, new_inst,
                                              inst.project_id,
                                              inst.user_id).AndReturn(None)
        db.constraint(host=mox.IgnoreArg()).AndReturn('constraint')
        db.instance_destroy(self.context, inst.uuid, 'constraint')

        if self.is_cells:
            self.mox.StubOutWithMock(self.compute_api, '_cast_to_cells')
            self.compute_api._cast_to_cells(
                self.context, db_inst, 'delete')

        self.mox.ReplayAll()

        self.compute_api.delete(self.context, db_inst)

 def test_destroy_with_not_equal_constraint_met(self):
     ctx = context.get_admin_context()
     instance = db.instance_create(ctx, {'task_state': 'deleting'})
     constraint = db.constraint(task_state=db.not_equal('error', 'resize'))
     db.instance_destroy(ctx, instance['uuid'], constraint)
     self.assertRaises(exception.InstanceNotFound, db.instance_get_by_uuid,
                       ctx, instance['uuid'])

    def destroy(self):
        if not self.obj_attr_is_set('id'):
            raise exception.ObjectActionError(action='destroy',
                                              reason='already destroyed')
        if not self.obj_attr_is_set('uuid'):
            raise exception.ObjectActionError(action='destroy',
                                              reason='no uuid')
        if not self.obj_attr_is_set('host') or not self.host:
            # NOTE(danms): If our host is not set, avoid a race
            constraint = db.constraint(host=db.equal_any(None))
        else:
            constraint = None

        cell_type = cells_opts.get_cell_type()
        if cell_type is not None:
            stale_instance = self.obj_clone()

        try:
            db_inst = db.instance_destroy(self._context, self.uuid,
                                          constraint=constraint)
            self._from_db_object(self._context, self, db_inst)
        except exception.ConstraintNotMet:
            raise exception.ObjectActionError(action='destroy',
                                              reason='host changed')
        if cell_type == 'compute':
            cells_api = cells_rpcapi.CellsAPI()
            cells_api.instance_destroy_at_top(self._context, stale_instance)
        delattr(self, base.get_attrname('id'))

 def test_destroy_with_not_equal_constraint_not_met(self):
     ctx = context.get_admin_context()
     instance = db.instance_create(ctx, {"vm_state": "active"})
     constraint = db.constraint(vm_state=db.not_equal("active", "error"))
     self.assertRaises(exception.ConstraintNotMet, db.instance_destroy, ctx, instance["uuid"], constraint)
     instance = db.instance_get_by_uuid(ctx, instance["uuid"])
     self.assertFalse(instance["deleted"])

 def test_destroy_with_not_equal_constraint_not_met(self):
     ctx = context.get_admin_context()
     instance = db.instance_create(ctx, {'vm_state': 'active'})
     constraint = db.constraint(vm_state=db.not_equal('active', 'error'))
     self.assertRaises(exception.ConstraintNotMet, db.instance_destroy,
                       ctx, instance['uuid'], constraint)
     instance = db.instance_get_by_uuid(ctx, instance['uuid'])
     self.assertFalse(instance['deleted'])

    def destroy(self, context):
        if not self.obj_attr_is_set("id"):
            raise exception.ObjectActionError(action="destroy", reason="already destroyed")
        if not self.obj_attr_is_set("uuid"):
            raise exception.ObjectActionError(action="destroy", reason="no uuid")
        if not self.obj_attr_is_set("host") or not self.host:
            # NOTE(danms): If our host is not set, avoid a race
            constraint = db.constraint(host=db.equal_any(None))
        else:
            constraint = None

        try:
            db.instance_destroy(context, self.uuid, constraint=constraint)
        except exception.ConstraintNotMet:
            raise exception.ObjectActionError(action="destroy", reason="host changed")
        delattr(self, base.get_attrname("id"))

    def destroy(self, context):
        if not self.obj_attr_is_set('id'):
            raise exception.ObjectActionError(action='destroy',
                                              reason='already destroyed')
        if not self.obj_attr_is_set('uuid'):
            raise exception.ObjectActionError(action='destroy',
                                              reason='no uuid')
        if not self.obj_attr_is_set('host') or not self.host:
            # NOTE(danms): If our host is not set, avoid a race
            constraint = db.constraint(host=db.equal_any(None))
        else:
            constraint = None

        try:
            db_inst = db.instance_destroy(context, self.uuid,
                                          constraint=constraint)
            self._from_db_object(context, self, db_inst)
        except exception.ConstraintNotMet:
            raise exception.ObjectActionError(action='destroy',
                                              reason='host changed')
        delattr(self, base.get_attrname('id'))

 def test_destroy_with_not_equal_constraint_met(self):
     ctx = context.get_admin_context()
     instance = db.instance_create(ctx, {"task_state": "deleting"})
     constraint = db.constraint(task_state=db.not_equal("error", "resize"))
     db.instance_destroy(ctx, instance["uuid"], constraint)
     self.assertRaises(exception.InstanceNotFound, db.instance_get_by_uuid, ctx, instance["uuid"])