Python db.block_device_mapping_create函数代码示例

    def _block_device_mapping_create(self, instance_uuid, mappings):
        volumes = []
        for bdm in mappings:
            db.block_device_mapping_create(self.context, bdm)
            if 'volume_id' in bdm:
                values = {'id': bdm['volume_id']}
                for bdm_key, vol_key in [('snapshot_id', 'snapshot_id'),
                                         ('snapshot_size', 'volume_size'),
                                         ('delete_on_termination',
                                          'delete_on_termination')]:
                    if bdm_key in bdm:
                        values[vol_key] = bdm[bdm_key]
                    kwargs = {'name': 'bdmtest-volume',
                              'description': 'bdm test volume description',
                              'status': 'available',
                              'host': 'fake',
                              'size': 1,
                              'attach_status': 'detached',
                              'volume_id': values['id']}
                vol = self.volume_api.create_with_kwargs(self.context,
                                                        **kwargs)
                if 'snapshot_id' in values:
                    self.volume_api.create_snapshot(self.context,
                                                    vol,
                                                    'snapshot-bdm',
                                                    'fake snap for bdm tests',
                                                    values['snapshot_id'])

                self.volume_api.attach(self.context, vol,
                                       instance_uuid, bdm['device_name'])
                volumes.append(vol)
        return volumes

    def _block_device_mapping_create(self, instance_uuid, mappings):
        volumes = []
        for bdm in mappings:
            db.block_device_mapping_create(self.context, bdm)
            if "volume_id" in bdm:
                values = {"id": bdm["volume_id"]}
                for bdm_key, vol_key in [
                    ("snapshot_id", "snapshot_id"),
                    ("snapshot_size", "volume_size"),
                    ("delete_on_termination", "delete_on_termination"),
                ]:
                    if bdm_key in bdm:
                        values[vol_key] = bdm[bdm_key]
                    kwargs = {
                        "name": "bdmtest-volume",
                        "description": "bdm test volume description",
                        "status": "available",
                        "host": self.volume.host,
                        "size": 1,
                        "attach_status": "detached",
                        "volume_id": values["id"],
                    }
                vol = self.volume_api.create_with_kwargs(self.context, **kwargs)
                if "snapshot_id" in values:
                    self.volume_api.create_snapshot(
                        self.context, vol, "snapshot-bdm", "fake snap for bdm tests", values["snapshot_id"]
                    )

                self.volume_api.attach(self.context, vol, instance_uuid, bdm["device_name"])
                volumes.append(vol)
        return volumes

def add_block_dev(context, instance_uuid, device_id):
    bdev = {
                'instance_uuid' : instance_uuid,
                'volume_id'     : create_uuid(),
                'device_name'   : device_id,
                'delete_on_termination' : True,
                'volume_size'   : ''
            }
    db.block_device_mapping_create(context, bdev)

    def test_block_device_mapping_update_or_create(self):
        self.mox.StubOutWithMock(db, "block_device_mapping_create")
        self.mox.StubOutWithMock(db, "block_device_mapping_update")
        self.mox.StubOutWithMock(db, "block_device_mapping_update_or_create")
        db.block_device_mapping_create(self.context, "fake-bdm")
        db.block_device_mapping_update(self.context, "fake-id", {"id": "fake-id"})
        db.block_device_mapping_update_or_create(self.context, "fake-bdm")

        self.mox.ReplayAll()
        self.conductor.block_device_mapping_create(self.context, "fake-bdm")
        self.conductor.block_device_mapping_update(self.context, "fake-id", {})
        self.conductor.block_device_mapping_update_or_create(self.context, "fake-bdm")

def create_instance(context, instance=None, driver=None):
    """Create a test instance"""

    if instance == None:
        instance = {}

    system_metadata = instance.get('system_metadata', {})
    instance_type = flavors.get_flavor_by_name('m1.tiny')
    system_metadata.update(flavors.save_flavor_info(dict(), instance_type))

    instance.setdefault('user_id', context.user_id)
    instance.setdefault('project_id', context.project_id)
    instance.setdefault('instance_type_id', instance_type['id'])
    instance.setdefault('system_metadata', system_metadata)
    instance.setdefault('image_id', 1)
    instance.setdefault('image_ref', 1)
    instance.setdefault('reservation_id', 'r-fakeres')
    instance.setdefault('launch_time', '10')
    instance.setdefault('mac_address', "ca:ca:ca:01")
    instance.setdefault('ami_launch_index', 0)
    instance.setdefault('vm_state', vm_states.ACTIVE)
    instance.setdefault('root_gb', 10)
    instance.setdefault('ephemeral_gb', 10)
    instance.setdefault('memory_mb', 512)
    instance.setdefault('vcpus', 1)
    instance.setdefault('info_cache', {'network_info':json.dumps({})})

        # We should record in the quotas information about this instance.
    reservations = quota.QUOTAS.reserve(context, instances=1,
                         ram=instance['memory_mb'],
                         cores=instance['vcpus'])

    context.elevated()
    instance_ref = db.instance_create(context, instance)
    db.block_device_mapping_create(context,
            {'source_type': 'image',
             'destination_type': 'local',
             'device_type': 'disk',
             'image_id': 1,
             'boot_index': 0,
             'instance_uuid': instance_ref['uuid']},
             legacy=False)

    if driver:
        # Add this instance to the driver
        driver.instances[instance_ref.name] = FakeInstance(instance_ref.name,
                                                           instance_ref.get('power_state',
                                                                             power_state.RUNNING))

    quota.QUOTAS.commit(context, reservations)

    return instance_ref['uuid']

    def test_block_device_mapping_update_or_create(self):
        self.mox.StubOutWithMock(db, 'block_device_mapping_create')
        self.mox.StubOutWithMock(db, 'block_device_mapping_update')
        self.mox.StubOutWithMock(db, 'block_device_mapping_update_or_create')
        db.block_device_mapping_create(self.context, 'fake-bdm')
        db.block_device_mapping_update(self.context,
                                       'fake-id', {'id': 'fake-id'})
        db.block_device_mapping_update_or_create(self.context, 'fake-bdm')

        self.mox.ReplayAll()
        self.conductor.block_device_mapping_create(self.context, 'fake-bdm')
        self.conductor.block_device_mapping_update(self.context, 'fake-id', {})
        self.conductor.block_device_mapping_update_or_create(self.context,
                                                             'fake-bdm')

    def create(self, context):
        if self.obj_attr_is_set('id'):
            raise exception.ObjectActionError(action='create',
                                              reason='already created')
        updates = self.obj_get_changes()
        if 'instance' in updates:
            raise exception.ObjectActionError(action='create',
                                              reason='instance assigned')

        db_bdm = db.block_device_mapping_create(context, updates, legacy=False)
        cells_api = cells_rpcapi.CellsAPI()
        cells_api.bdm_update_or_create_at_top(context, db_bdm, create=True)
        self._from_db_object(context, self, db_bdm)

    def _create(self, context, update_or_create=False):
        """Create the block device record in the database.

        In case the id field is set on the object, and if the instance is set
        raise an ObjectActionError. Resets all the changes on the object.

        Returns None

        :param context: security context used for database calls
        :param update_or_create: consider existing block devices for the
                instance based on the device name and swap, and only update
                the ones that match. Normally only used when creating the
                instance for the first time.
        """
        cell_type = cells_opts.get_cell_type()
        if cell_type == 'api':
            raise exception.ObjectActionError(
                    action='create',
                    reason='BlockDeviceMapping cannot be '
                           'created in the API cell.')

        if self.obj_attr_is_set('id'):
            raise exception.ObjectActionError(action='create',
                                              reason='already created')
        updates = self.obj_get_changes()
        if 'instance' in updates:
            raise exception.ObjectActionError(action='create',
                                              reason='instance assigned')

        cells_create = update_or_create or None
        if update_or_create:
            db_bdm = db.block_device_mapping_update_or_create(
                    context, updates, legacy=False)
        else:
            db_bdm = db.block_device_mapping_create(
                    context, updates, legacy=False)

        self._from_db_object(context, self, db_bdm)
        # NOTE(alaski): bdms are looked up by instance uuid and device_name
        # so if we sync up with no device_name an entry will be created that
        # will not be found on a later update_or_create call and a second bdm
        # create will occur.
        if cell_type == 'compute' and db_bdm.get('device_name') is not None:
            cells_api = cells_rpcapi.CellsAPI()
            cells_api.bdm_update_or_create_at_top(
                    context, self, create=cells_create)

    def create(self, context):
        cell_type = cells_opts.get_cell_type()
        if cell_type == 'api':
            raise exception.ObjectActionError(
                    action='create',
                    reason='BlockDeviceMapping cannot be '
                           'created in the API cell.')

        if self.obj_attr_is_set('id'):
            raise exception.ObjectActionError(action='create',
                                              reason='already created')
        updates = self.obj_get_changes()
        if 'instance' in updates:
            raise exception.ObjectActionError(action='create',
                                              reason='instance assigned')

        db_bdm = db.block_device_mapping_create(context, updates, legacy=False)
        self._from_db_object(context, self, db_bdm)
        if cell_type == 'compute':
            cells_api = cells_rpcapi.CellsAPI()
            cells_api.bdm_update_or_create_at_top(context, self, create=True)

    def _create(self, context, update_or_create=False):
        """Create the block device record in the database.

        In case the id field is set on the object, and if the instance is set
        raise an ObjectActionError. Resets all the changes on the object.

        Returns None

        :param context: security context used for database calls
        :param update_or_create: consider existing block devices for the
                instance based on the device name and swap, and only update
                the ones that match. Normally only used when creating the
                instance for the first time.
        """
        cell_type = cells_opts.get_cell_type()
        if cell_type == "api":
            raise exception.ObjectActionError(
                action="create", reason="BlockDeviceMapping cannot be " "created in the API cell."
            )

        if self.obj_attr_is_set("id"):
            raise exception.ObjectActionError(action="create", reason="already created")
        updates = self.obj_get_changes()
        if "instance" in updates:
            raise exception.ObjectActionError(action="create", reason="instance assigned")

        cells_create = update_or_create or None
        if update_or_create:
            db_bdm = db.block_device_mapping_update_or_create(context, updates, legacy=False)
        else:
            db_bdm = db.block_device_mapping_create(context, updates, legacy=False)

        self._from_db_object(context, self, db_bdm)
        if cell_type == "compute":
            cells_api = cells_rpcapi.CellsAPI()
            cells_api.bdm_update_or_create_at_top(context, self, create=cells_create)