Exemplo n.º 1
0
    def test_copy_volume_to_image(self):
        drv = self._driver

        vol = db_fakes.get_fake_volume_info()

        image_meta = db_fakes.get_fake_image_meta()

        self.stubs.Set(drv, 'local_path', self.fake_local_path)

        self.mox.StubOutWithMock(image_utils, 'upload_volume')

        temp_vhd_path = os.path.join(CONF.image_conversion_dir,
                                     str(image_meta['id']) + ".vhd")

        image_utils.upload_volume(None, None, image_meta, temp_vhd_path, 'vpc')

        self.mox.StubOutWithMock(windows_utils.WindowsUtils,
                                 'copy_vhd_disk')

        windows_utils.WindowsUtils.copy_vhd_disk(self.fake_local_path(vol),
                                                 temp_vhd_path)

        self.mox.ReplayAll()

        drv.copy_volume_to_image(None, vol, None, image_meta)
Exemplo n.º 2
0
    def _copy_volume_to_image(self, context, volume, image_service,
                              image_meta):
        """Copy the volume to the specified image."""

        # If snapshots exist, flatten to a temporary image, and upload it

        active_file = self.get_active_image_from_info(volume)
        active_file_path = os.path.join(self._local_volume_dir(volume),
                                        active_file)
        info = self._qemu_img_info(active_file_path)
        backing_file = info.backing_file

        root_file_fmt = info.file_format

        tmp_params = {
            'prefix': '%s.temp_image.%s' % (volume['id'], image_meta['id']),
            'suffix': '.img'
        }
        with image_utils.temporary_file(**tmp_params) as temp_path:
            if backing_file or (root_file_fmt != 'raw'):
                # Convert due to snapshots
                # or volume data not being stored in raw format
                #  (upload_volume assumes raw format input)
                image_utils.convert_image(active_file_path, temp_path, 'raw')
                upload_path = temp_path
            else:
                upload_path = active_file_path

            image_utils.upload_volume(context, image_service, image_meta,
                                      upload_path)
Exemplo n.º 3
0
    def test_upload_volume_with_bps_limit(self, mock_stat):
        bps_limit = 1048576
        image_meta = {"id": 1, "disk_format": "qcow2"}
        TEST_RET = (
            "image: qemu.qcow2\n"
            "file_format: qcow2 \n"
            "virtual_size: 50M (52428800 bytes)\n"
            "cluster_size: 65536\n"
            "disk_size: 196K (200704 bytes)"
        )

        self.override_config("volume_copy_bps_limit", bps_limit)
        prefix = ("cgexec", "-g", "blkio:test")

        cmd = prefix + ("qemu-img", "convert", "-O", "qcow2", mox.IgnoreArg(), mox.IgnoreArg())

        m = self._mox
        m.StubOutWithMock(utils, "execute")
        m.StubOutWithMock(volume_utils, "setup_blkio_cgroup")
        m.StubOutWithMock(volume_utils, "check_for_odirect_support")

        volume_utils.setup_blkio_cgroup(mox.IgnoreArg(), mox.IgnoreArg(), bps_limit).AndReturn(prefix)
        utils.execute(*cmd, run_as_root=True)
        utils.execute("env", "LC_ALL=C", "qemu-img", "info", mox.IgnoreArg(), run_as_root=True).AndReturn(
            (TEST_RET, "ignored")
        )

        m.ReplayAll()
        image_utils.upload_volume(context, FakeImageService(), image_meta, "/dev/loop1")
        m.VerifyAll()
Exemplo n.º 4
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     with temp_lvm_device(self, volume):
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   self._mapper_path(volume))
Exemplo n.º 5
0
def upload_volume(context,
                  image_service,
                  image_meta,
                  volume_path,
                  volume,
                  volume_format='raw',
                  run_as_root=True,
                  compress=True):
    # retrieve store information from extra-specs
    store_id = volume.volume_type.extra_specs.get('image_service:store_id')

    # This fetches the image_id from volume glance metadata and pass
    # it to the driver calling it during upload volume to image operation
    base_image_ref = None
    if volume.glance_metadata:
        base_image_ref = volume.glance_metadata.get('image_id')
    image_utils.upload_volume(context,
                              image_service,
                              image_meta,
                              volume_path,
                              volume_format=volume_format,
                              run_as_root=run_as_root,
                              compress=compress,
                              store_id=store_id,
                              base_image_ref=base_image_ref)
Exemplo n.º 6
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        # If snapshots exist, flatten to a temporary image, and upload it

        active_file = self.get_active_image_from_info(volume)
        active_file_path = os.path.join(self._local_volume_dir(volume),
                                        active_file)
        backing_file = self._vhdutils.get_vhd_parent_path(active_file_path)
        root_file_fmt = self.get_volume_format(volume)

        temp_path = None

        try:
            if backing_file:
                temp_file_name = '%s.temp_image.%s.%s' % (
                    volume.id, image_meta['id'], root_file_fmt)
                temp_path = os.path.join(self._local_volume_dir(volume),
                                         temp_file_name)

                self._vhdutils.convert_vhd(active_file_path, temp_path)
                upload_path = temp_path
            else:
                upload_path = active_file_path

            image_utils.upload_volume(context, image_service, image_meta,
                                      upload_path, root_file_fmt)
        finally:
            if temp_path:
                self._delete(temp_path)
Exemplo n.º 7
0
    def test_upload_volume(self, bps_limit=0):
        image_meta = {'id': 1, 'disk_format': 'qcow2'}
        TEST_RET = "image: qemu.qcow2\n"\
                   "file_format: qcow2 \n"\
                   "virtual_size: 50M (52428800 bytes)\n"\
                   "cluster_size: 65536\n"\
                   "disk_size: 196K (200704 bytes)"
        if bps_limit:
            CONF.set_override('volume_copy_bps_limit', bps_limit)
            prefix = ('cgexec', '-g', 'blkio:test')
            postfix = ('-t', 'none')
        else:
            prefix = postfix = ()
        cmd = prefix + ('qemu-img', 'convert', '-O', 'qcow2',
                        mox.IgnoreArg(), mox.IgnoreArg()) + postfix

        m = self._mox
        m.StubOutWithMock(utils, 'execute')
        m.StubOutWithMock(volume_utils, 'setup_blkio_cgroup')

        volume_utils.setup_blkio_cgroup(mox.IgnoreArg(), mox.IgnoreArg(),
                                        bps_limit).AndReturn(prefix)
        utils.execute(*cmd, run_as_root=True)
        utils.execute(
            'env', 'LC_ALL=C', 'qemu-img', 'info',
            mox.IgnoreArg(), run_as_root=True).AndReturn(
                (TEST_RET, 'ignored')
            )

        m.ReplayAll()

        image_utils.upload_volume(context, FakeImageService(),
                                  image_meta, '/dev/loop1')
        m.VerifyAll()
Exemplo n.º 8
0
    def test_copy_volume_to_image(self):
        mox = self._mox
        drv = self._driver

        vol = db_fakes.get_fake_volume_info()

        image_meta = db_fakes.get_fake_image_meta()

        self.stubs.Set(drv, 'local_path', self.fake_local_path)

        mox.StubOutWithMock(image_utils, 'upload_volume')

        temp_vhd_path = os.path.join(CONF.image_conversion_dir,
                                     str(image_meta['id']) + ".vhd")

        image_utils.upload_volume(None, None, image_meta, temp_vhd_path, 'vpc')

        self._mox.StubOutWithMock(windows_utils.WindowsUtils,
                                  'copy_vhd_disk')

        windows_utils.WindowsUtils.copy_vhd_disk(self.fake_local_path(vol),
                                                 temp_vhd_path)

        mox.ReplayAll()

        drv.copy_volume_to_image(None, vol, None, image_meta)

        mox.VerifyAll()
Exemplo n.º 9
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.error('begin time of COPY_VOLUME_TO_IMAGE is %s' %
                  (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
        container_format = image_meta.get('container_format')
        file_name = image_meta.get('id')
        full_url = None
        if container_format in ['fs_vgw_url', 'vcloud_vgw_url', 'aws_vgw_url']:
            LOG.debug('get the vgw url')
            vgw_url = CONF.vgw.vgw_url.get(container_format)
            if vgw_url:
                full_url = vgw_url + '/' + file_name

            image_utils.upload_volume_to_vgw(context,
                                             image_service, image_meta,
                                             self.local_path(volume), volume,
                                             full_url)
            #create a empty file to glance
            with image_utils.temporary_file() as tmp:
                image_utils.upload_volume(context, image_service, image_meta,
                                          tmp)
            fileutils.delete_if_exists(tmp)
            LOG.error('end time of COPY_VOLUME_TO_IMAGE is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
        else:
            image_utils.upload_volume(context, image_service, image_meta,
                                      self.local_path(volume))
Exemplo n.º 10
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        if not os.path.exists(
                self.configuration.provider_image_conversion_dir):
            fileutils.ensure_tree(
                self.configuration.provider_image_conversion_dir)
        provider_volume_id = self._get_provider_volumeid_from_volume(volume)
        task_ret = self.adpter.export_volume(
            provider_volume_id,
            self.configuration.provider_image_conversion_dir,
            str(image_meta['id']),
            cgw_host_id=self.configuration.cgw_host_id,
            cgw_host_ip=self.configuration.cgw_host_ip,
            cgw_username=self.configuration.cgw_username,
            cgw_certificate=self.configuration.cgw_certificate,
            transfer_station=self.configuration.storage_tmp_dir)
        if not task_ret:
            raise exception_ex.ProviderExportVolumeError
        temp_path = os.path.join(
            self.configuration.provider_image_conversion_dir,
            str(image_meta['id']))
        upload_image = temp_path

        try:
            image_utils.upload_volume(context, image_service, image_meta,
                                      upload_image)
        finally:
            fileutils.delete_if_exists(upload_image)
Exemplo n.º 11
0
    def test_upload_volume_with_bps_limit(self, mock_stat):
        bps_limit = 1048576
        image_meta = {'id': 1, 'disk_format': 'qcow2'}
        TEST_RET = "image: qemu.qcow2\n"\
                   "file_format: qcow2 \n"\
                   "virtual_size: 50M (52428800 bytes)\n"\
                   "cluster_size: 65536\n"\
                   "disk_size: 196K (200704 bytes)"

        self.override_config('volume_copy_bps_limit', bps_limit)
        prefix = ('cgexec', '-g', 'blkio:test')

        cmd = prefix + ('qemu-img', 'convert', '-O', 'qcow2', mox.IgnoreArg(),
                        mox.IgnoreArg())

        m = self._mox
        m.StubOutWithMock(utils, 'execute')
        m.StubOutWithMock(volume_utils, 'setup_blkio_cgroup')
        m.StubOutWithMock(volume_utils, 'check_for_odirect_support')

        volume_utils.setup_blkio_cgroup(mox.IgnoreArg(), mox.IgnoreArg(),
                                        bps_limit).AndReturn(prefix)
        utils.execute(*cmd, run_as_root=True)
        utils.execute('env',
                      'LC_ALL=C',
                      'qemu-img',
                      'info',
                      mox.IgnoreArg(),
                      run_as_root=True).AndReturn((TEST_RET, 'ignored'))

        m.ReplayAll()
        image_utils.upload_volume(context, FakeImageService(), image_meta,
                                  '/dev/loop1')
        m.VerifyAll()
Exemplo n.º 12
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        # If snapshots exist, flatten to a temporary image, and upload it

        active_file = self.get_active_image_from_info(volume)
        active_file_path = os.path.join(self._local_volume_dir(volume),
                                        active_file)
        backing_file = self._vhdutils.get_vhd_parent_path(active_file_path)
        root_file_fmt = self.get_volume_format(volume)

        temp_path = None

        try:
            if backing_file:
                temp_file_name = '%s.temp_image.%s.%s' % (
                    volume.id,
                    image_meta['id'],
                    root_file_fmt)
                temp_path = os.path.join(self._local_volume_dir(volume),
                                         temp_file_name)

                self._vhdutils.convert_vhd(active_file_path, temp_path)
                upload_path = temp_path
            else:
                upload_path = active_file_path

            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      upload_path,
                                      root_file_fmt)
        finally:
            if temp_path:
                self._delete(temp_path)
Exemplo n.º 13
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     with temp_lvm_device(self, volume):
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   self._mapper_path(volume))
Exemplo n.º 14
0
    def test_upload_volume(self):
        image_meta = {'id': 1, 'disk_format': 'qcow2'}
        TEST_RET = "image: qemu.qcow2\n"\
                   "file_format: qcow2 \n"\
                   "virtual_size: 50M (52428800 bytes)\n"\
                   "cluster_size: 65536\n"\
                   "disk_size: 196K (200704 bytes)"

        m = self._mox
        m.StubOutWithMock(utils, 'execute')

        utils.execute('qemu-img',
                      'convert',
                      '-O',
                      'qcow2',
                      mox.IgnoreArg(),
                      mox.IgnoreArg(),
                      run_as_root=True)
        utils.execute('env',
                      'LC_ALL=C',
                      'LANG=C',
                      'qemu-img',
                      'info',
                      mox.IgnoreArg(),
                      run_as_root=True).AndReturn((TEST_RET, 'ignored'))

        m.ReplayAll()

        image_utils.upload_volume(context, FakeImageService(), image_meta,
                                  '/dev/loop1')
        m.VerifyAll()
Exemplo n.º 15
0
Arquivo: spdk.py Projeto: mahak/cinder
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        volume['provider_location'] = (
            self.create_export(context, volume, None)['provider_location'])
        connection_data = self.initialize_connection(volume, None)['data']
        target_connector = (
            connector.InitiatorConnector.factory(initiator.NVME,
                                                 utils.get_root_helper()))

        try:
            device_info = target_connector.connect_volume(connection_data)
        except Exception:
            LOG.info('Could not connect SPDK target device')
            return

        connection_data['device_path'] = device_info['path']

        try:
            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      device_info['path'])

        finally:
            target_connector.disconnect_volume(connection_data, volume)
Exemplo n.º 16
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        # If snapshots exist, flatten to a temporary image, and upload it

        active_file = self.get_active_image_from_info(volume)
        active_file_path = "%s/%s" % (self._local_volume_dir(volume), active_file)
        backing_file = self._get_backing_file_for_path(active_file_path)
        if backing_file is not None:
            snapshots_exist = True
        else:
            snapshots_exist = False

        root_file_fmt = self._get_file_format_for_path(self._local_path_volume(volume))

        temp_path = None

        try:
            if snapshots_exist or (root_file_fmt != "raw"):
                # Convert due to snapshots
                # or volume data not being stored in raw format
                #  (upload_volume assumes raw format input)
                temp_path = "%s/%s.temp_image.%s" % (self._local_volume_dir(volume), volume["id"], image_meta["id"])

                image_utils.convert_image(active_file_path, temp_path, "raw")
                upload_path = temp_path
            else:
                upload_path = active_file_path

            image_utils.upload_volume(context, image_service, image_meta, upload_path)
        finally:
            if temp_path is not None:
                self._execute("rm", "-f", temp_path)
Exemplo n.º 17
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        # retrieve store information from extra-specs
        store_id = volume.volume_type.extra_specs.get('image_service:store_id')
        volume['provider_location'] = (self.create_export(
            context, volume, None)['provider_location'])
        connection_data = self.initialize_connection(volume, None)['data']
        target_connector = (connector.InitiatorConnector.factory(
            initiator.NVME, utils.get_root_helper()))

        try:
            device_info = target_connector.connect_volume(connection_data)
        except Exception:
            LOG.info('Could not connect SPDK target device')
            return

        connection_data['device_path'] = device_info['path']

        try:
            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      device_info['path'],
                                      store_id=store_id)

        finally:
            target_connector.disconnect_volume(connection_data, volume)
Exemplo n.º 18
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        # If snapshots exist, flatten to a temporary image, and upload it

        active_file = self.get_active_image_from_info(volume)
        active_file_path = '%s/%s' % (self._local_volume_dir(volume),
                                      active_file)
        info = self._qemu_img_info(active_file_path)
        backing_file = info.backing_file
        if backing_file:
            snapshots_exist = True
        else:
            snapshots_exist = False

        root_file_fmt = info.file_format

        tmp_params = {
            'prefix': '%s.temp_image.%s' % (volume['id'], image_meta['id']),
            'suffix': '.img'
        }
        with image_utils.temporary_file(**tmp_params) as temp_path:
            if snapshots_exist or (root_file_fmt != 'raw'):
                # Convert due to snapshots
                # or volume data not being stored in raw format
                #  (upload_volume assumes raw format input)
                image_utils.convert_image(active_file_path, temp_path, 'raw')
                upload_path = temp_path
            else:
                upload_path = active_file_path

            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      upload_path)
Exemplo n.º 19
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     LOG.error('begin time of COPY_VOLUME_TO_IMAGE is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
     container_format=image_meta.get('container_format')
     file_name=image_meta.get('id')
     full_url=None
     if container_format in ['fs_vgw_url','vcloud_vgw_url','aws_vgw_url']:
         LOG.debug('get the vgw url')
         vgw_url = CONF.vgw.vgw_url.get(container_format)
         if  vgw_url:
             full_url=vgw_url+'/'+file_name
          
         image_utils.upload_volume_to_vgw(context, image_service, image_meta, self.local_path(volume), volume, full_url)
         #create a empty file to glance
         with image_utils.temporary_file() as tmp:
             image_utils.upload_volume(context,
                                       image_service,
                                       image_meta,
                                       tmp)
         fileutils.delete_if_exists(tmp)
         LOG.error('end time of COPY_VOLUME_TO_IMAGE is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
     else:    
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   self.local_path(volume))
Exemplo n.º 20
0
            def _unused():
                # todo(wangfeng)
                # pdb.set_trace()
                # 1. get the vmdk file.

                volume_id = volume['id']
                if volume['attach_status'] == 'attached':
                    # nova_client = nova.novaclient(context)
                    # node_name = nova_client.servers.get(instance_id)._
                    # info['OS-EXT-SRV-ATTR:hypervisor_hostname']
                    the_vapp = self._get_vcloud_vapp(volume['instance_uuid'])
                    vmdk_url = self._query_vmdk_url(the_vapp)
                    local_file_name = '%s/%s.vmdk' % (
                        CONF.vcloud.vcloud_conversion_dir, volume_id)
                    self._download_vmdk_from_vcloud(context, vmdk_url,
                                                    local_file_name)

                    # volume_id = volume['id']
                    # create_info = {'snapshot_id':volume['snapshot_id'],
                    #              'type':'qcow2',
                    #             'new_file':'snapshot_file'}

                    # self._nova_api.create_volume_snapshot(context,volume_id,create_info)
                    # local_file_name = '%s/%s.vmdk' % (CONVERT_DIR, volume_id)
                else:
                    local_file_name = '%s/%s.vmdk' % (
                        CONF.vcloud.vcloud_volumes_dir, volume_id)
                    if not os.path.exists(local_file_name):
                        LOG.error('volume file %s do not exist' %
                                  local_file_name)
                        return

                # 1. the file is vmdk, convert it to qcow2
                # converted_file_name = '%s/converted-file.qcow2' %
                # CONF.vcloud.vcloud_conversion_dir
                # convert_commond = "qemu-img convert -f %s -O %s %s %s" % \
                #                      ('vmdk',
                #                     'qcow2',
                #                    local_file_name,
                #                   converted_file_name)
                # convert_result = subprocess.call([convert_commond],shell=True)
                # if convert_result != 0:
                # do something, change metadata
                # LOG.error('converting file failed')

                # 2. upload to glance

                # file_size = os.path.getsize(converted_file_name)

                # The properties and other fields that we need to set for the image.
                # image_meta['disk_format'] = 'qcow2'
                # image_meta['status'] = 'active'
                # image_meta['size'] = file_size
                # image_meta['properties'] = {'owner_id': volume['project_id']}

                # image_utils.upload_volume(context,image_service,image_meta,converted_file_name,'qcow2')

                image_utils.upload_volume(context, image_service, image_meta,
                                          local_file_name, 'vmdk')
Exemplo n.º 21
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        # Copy the volume to the image conversion dir
        temp_vhd_path = os.path.join(self.configuration.image_conversion_dir,
                                     str(image_meta['id']) + ".vhd")
        self.utils.copy_vhd_disk(self.local_path(volume), temp_vhd_path)
        image_utils.upload_volume(context, image_service, image_meta,
                                  temp_vhd_path, 'vpc')
Exemplo n.º 22
0
 def _use_image_utils_to_upload_volume(self, context, volume, image_service,
                                       image_meta):
     sr_uuid, vdi_uuid = volume['provider_location'].split('/')
     with self.nfs_ops.volume_attached_here(FLAGS.xenapi_nfs_server,
                                            FLAGS.xenapi_nfs_serverpath,
                                            sr_uuid, vdi_uuid,
                                            True) as device:
         image_utils.upload_volume(context, image_service, image_meta,
                                   device)
Exemplo n.º 23
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy a  volume to a new image."""
     LOG.debug("Enter in copy image to volume for disco.")
     try:
         device_info = self._attach_volume(volume)
         image_utils.upload_volume(context, image_service, image_meta,
                                   device_info['path'])
     finally:
         self._detach_volume(volume)
Exemplo n.º 24
0
    def test_copy_volume_to_image(self):
        """Expected behaviour for copy_volume_to_image."""
        self.mox.StubOutWithMock(image_utils, "upload_volume")

        image_utils.upload_volume(context, self.TEST_IMAGE_SERVICE, self.TEST_IMAGE_META, self.TEST_VOLPATH)

        self.mox.ReplayAll()

        self._driver.copy_volume_to_image(context, self.TEST_VOLUME, self.TEST_IMAGE_SERVICE, self.TEST_IMAGE_META)
Exemplo n.º 25
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        # Copy the volume to the image conversion dir
        temp_vhd_path = os.path.join(self.configuration.image_conversion_dir,
                                     str(image_meta['id']) + ".vhd")
        self.utils.copy_vhd_disk(self.local_path(volume), temp_vhd_path)
        image_utils.upload_volume(context, image_service, image_meta,
                                  temp_vhd_path, 'vpc')
Exemplo n.º 26
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     tmp_dir = self._image_conversion_dir()
     tmp_file = os.path.join(tmp_dir, volume["name"] + "-" + image_meta["id"])
     with fileutils.remove_path_on_error(tmp_file):
         args = ["rbd", "export", "--pool", self.configuration.rbd_pool, volume["name"], tmp_file]
         args.extend(self._ceph_args())
         self._try_execute(*args)
         image_utils.upload_volume(context, image_service, image_meta, tmp_file)
     os.unlink(tmp_file)
Exemplo n.º 27
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        # retrieve store information from extra-specs
        store_id = volume.volume_type.extra_specs.get('image_service:store_id')

        image_utils.upload_volume(context,
                                  image_service,
                                  image_meta,
                                  self.local_path(volume),
                                  store_id=store_id)
Exemplo n.º 28
0
    def test_copy_volume_to_image(self):
        fake_image_service = "fake-image-service"
        fake_image_meta = "fake-image-meta"

        self.mox.StubOutWithMock(image_utils, "upload_volume")
        image_utils.upload_volume({}, fake_image_service, fake_image_meta, self.fake_dev_path)

        self.mox.ReplayAll()
        self.driver.copy_volume_to_image({}, fake_volume, fake_image_service, fake_image_meta)

        self.mox.VerifyAll()
Exemplo n.º 29
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.debug(_("copy_volume_to_image %s.") % volume["name"])
        connector = {"initiator": self._get_iscsi_initiator(), "host": socket.gethostname()}

        iscsi_properties, volume_path = self._attach_volume(context, volume, connector)

        try:
            image_utils.upload_volume(context, image_service, image_meta, volume_path)
        finally:
            self.terminate_connection(volume, connector)
Exemplo n.º 30
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.debug(("copy_volume_to_image %s.") % volume["name"])

        properties = utils.brick_get_connector_properties()
        attach_info = self._attach_volume(context, volume, properties)

        try:
            image_utils.upload_volume(context, image_service, image_meta, attach_info["device"]["path"])
        finally:
            self._detach_volume(context, attach_info, volume, properties)
Exemplo n.º 31
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy a  volume to a new image."""
     LOG.debug("Enter in copy image to volume for disco.")
     try:
         device_info = self._attach_volume(volume)
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   device_info['path'])
     finally:
         self._detach_volume(volume)
Exemplo n.º 32
0
 def _use_image_utils_to_upload_volume(self, context, volume, image_service,
                                       image_meta):
     sr_uuid, vdi_uuid = volume['provider_location'].split('/')
     with self.nfs_ops.volume_attached_here(CONF.xenapi_nfs_server,
                                            CONF.xenapi_nfs_serverpath,
                                            sr_uuid, vdi_uuid,
                                            True) as device:
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   device)
Exemplo n.º 33
0
    def test_upload_volume_with_raw_image(self):
        image_meta = {"id": 1, "disk_format": "raw"}
        mox = self._mox

        mox.StubOutWithMock(image_utils, "convert_image")

        mox.ReplayAll()

        with tempfile.NamedTemporaryFile() as f:
            image_utils.upload_volume(context, FakeImageService(), image_meta, f.name)
        mox.VerifyAll()
Exemplo n.º 34
0
            def _unused():
                # todo(wangfeng)
                # pdb.set_trace()
                # 1. get the vmdk file.

                volume_id = volume['id']
                if volume['attach_status']=='attached':
                    # nova_client = nova.novaclient(context)
                    # node_name = nova_client.servers.get(instance_id)._
                    # info['OS-EXT-SRV-ATTR:hypervisor_hostname']
                    the_vapp = self._get_vcloud_vapp(volume['instance_uuid'])
                    vmdk_url = self._query_vmdk_url(the_vapp)
                    local_file_name = '%s/%s.vmdk' % (CONF.vcloud.vcloud_conversion_dir, volume_id)
                    self._download_vmdk_from_vcloud(context, vmdk_url,local_file_name)

                    # volume_id = volume['id']
                    # create_info = {'snapshot_id':volume['snapshot_id'],
                    #              'type':'qcow2',
                    #             'new_file':'snapshot_file'}

                    # self._nova_api.create_volume_snapshot(context,volume_id,create_info)
                    # local_file_name = '%s/%s.vmdk' % (CONVERT_DIR, volume_id)
                else:
                    local_file_name = '%s/%s.vmdk' % (CONF.vcloud.vcloud_volumes_dir, volume_id)
                    if not os.path.exists(local_file_name):
                        LOG.error('volume file %s do not exist' % local_file_name)
                        return

                # 1. the file is vmdk, convert it to qcow2
                # converted_file_name = '%s/converted-file.qcow2' %
                # CONF.vcloud.vcloud_conversion_dir
                # convert_commond = "qemu-img convert -f %s -O %s %s %s" % \
                #                      ('vmdk',
                #                     'qcow2',
                #                    local_file_name,
                #                   converted_file_name)
                # convert_result = subprocess.call([convert_commond],shell=True)
                # if convert_result != 0:
                # do something, change metadata
                # LOG.error('converting file failed')

                # 2. upload to glance

                # file_size = os.path.getsize(converted_file_name)

                # The properties and other fields that we need to set for the image.
                # image_meta['disk_format'] = 'qcow2'
                # image_meta['status'] = 'active'
                # image_meta['size'] = file_size
                # image_meta['properties'] = {'owner_id': volume['project_id']}

                # image_utils.upload_volume(context,image_service,image_meta,converted_file_name,'qcow2')

                image_utils.upload_volume(context,image_service,image_meta,local_file_name,'vmdk')
Exemplo n.º 35
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""

        LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
        (properties, attach_info) = self._attach_volume_syc(context, volume)

        try:
            image_utils.upload_volume(context, image_service, image_meta,
                                      attach_info['device']['path'])
        finally:
            self._detach_and_terminate_syc(context, attach_info, volume,
                                           properties)
Exemplo n.º 36
0
 def test_copy_volume_to_image(self):
     TEST_VOLUME = {'provider_location': '1 2 3 /dev/loop1'}
     TEST_IMAGE_SERVICE = "image_service"
     TEST_IMAGE_META = "image_meta"
     self.mox.StubOutWithMock(image_utils, 'upload_volume')
     self.mox.StubOutWithMock(self.drv, 'local_path')
     self.drv.local_path(TEST_VOLUME).AndReturn('/dev/loop1')
     image_utils.upload_volume(context, TEST_IMAGE_SERVICE, TEST_IMAGE_META,
                               '/dev/loop1')
     self.mox.ReplayAll()
     self.drv.copy_volume_to_image(context, TEST_VOLUME, TEST_IMAGE_SERVICE,
                                   TEST_IMAGE_META)
Exemplo n.º 37
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy a  volume to a new image."""
     LOG.debug("Enter in copy image to volume for disco.")
     try:
         attach_detach_volume = (
             disco_attach_detach.AttachDetachDiscoVolume(
                 self.configuration))
         device_info = attach_detach_volume._attach_volume(volume)
         image_utils.upload_volume(context, image_service, image_meta,
                                   device_info['path'])
     finally:
         attach_detach_volume._detach_volume(volume)
Exemplo n.º 38
0
 def test_copy_volume_to_image(self):
     TEST_VOLUME = {'provider_location': '1 2 3 /dev/loop1'}
     TEST_IMAGE_SERVICE = "image_service"
     TEST_IMAGE_META = "image_meta"
     self.mox.StubOutWithMock(image_utils, 'upload_volume')
     self.mox.StubOutWithMock(self.drv, 'local_path')
     self.drv.local_path(TEST_VOLUME).AndReturn('/dev/loop1')
     image_utils.upload_volume(context, TEST_IMAGE_SERVICE,
                               TEST_IMAGE_META, '/dev/loop1')
     self.mox.ReplayAll()
     self.drv.copy_volume_to_image(context, TEST_VOLUME, TEST_IMAGE_SERVICE,
                                   TEST_IMAGE_META)
Exemplo n.º 39
0
    def test_copy_volume_to_image(self):
        """Expected behaviour for copy_volume_to_image."""
        self.mox.StubOutWithMock(image_utils, 'upload_volume')

        image_utils.upload_volume(context, self.TEST_IMAGE_SERVICE,
                                  self.TEST_IMAGE_META, self.TEST_VOLPATH)

        self.mox.ReplayAll()

        self._driver.copy_volume_to_image(context, self.TEST_VOLUME,
                                          self.TEST_IMAGE_SERVICE,
                                          self.TEST_IMAGE_META)
Exemplo n.º 40
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.debug(_('copy_volume_to_image %s.') % volume['name'])

        properties = utils.brick_get_connector_properties()
        attach_info = self._attach_volume(context, volume, properties)

        try:
            image_utils.upload_volume(context, image_service, image_meta,
                                      attach_info['device']['path'])
        finally:
            self._detach_volume(context, attach_info, volume, properties)
Exemplo n.º 41
0
    def test_upload_volume_with_raw_image(self):
        image_meta = {'id': 1, 'disk_format': 'raw'}
        mox = self._mox

        mox.StubOutWithMock(image_utils, 'convert_image')

        mox.ReplayAll()

        with tempfile.NamedTemporaryFile() as f:
            image_utils.upload_volume(context, FakeImageService(), image_meta,
                                      f.name)
        mox.VerifyAll()
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     LOG.info("ScaleIO copy_volume_to_image volume: "+str(volume) + " image service: " + str(image_service) + " image meta: " + str(image_meta))
     properties = utils.brick_get_connector_properties()
     sdc_ip = properties['ip']
     LOG.debug("SDC ip is: {0}".format(sdc_ip))
     try:
         image_utils.upload_volume(context,
                               image_service,
                               image_meta,
                               self._attach_volume (volume, sdc_ip))
     finally:
         self._detach_volume(volume, sdc_ip)
Exemplo n.º 43
0
    def test_copy_volume_to_image(self):
        fake_image_service = 'fake-image-service'
        fake_image_meta = 'fake-image-meta'

        self.mox.StubOutWithMock(image_utils, 'upload_volume')
        image_utils.upload_volume({}, fake_image_service, fake_image_meta,
                                  self.fake_dev_path)

        self.mox.ReplayAll()
        self.driver.copy_volume_to_image({}, fake_volume, fake_image_service,
                                         fake_image_meta)

        self.mox.VerifyAll()
Exemplo n.º 44
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
       
        LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
        (properties,attach_info) = self._attach_volume_syc(context, volume)

        try:
            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      attach_info['device']['path'])
        finally:
            self._detach_and_terminate_syc(context,attach_info,volume,properties)
Exemplo n.º 45
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     tmp_dir = self._image_conversion_dir()
     tmp_file = os.path.join(tmp_dir,
                             volume['name'] + '-' + image_meta['id'])
     with fileutils.remove_path_on_error(tmp_file):
         args = ['rbd', 'export',
                 '--pool', self.configuration.rbd_pool,
                 volume['name'], tmp_file]
         args.extend(self._ceph_args())
         self._try_execute(*args)
         image_utils.upload_volume(context, image_service,
                                   image_meta, tmp_file)
     os.unlink(tmp_file)
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     LOG.info("ScaleIO copy_volume_to_image volume: " + str(volume) +
              " image service: " + str(image_service) + " image meta: " +
              str(image_meta))
     properties = utils.brick_get_connector_properties()
     sdc_ip = properties['ip']
     LOG.debug("SDC ip is: {0}".format(sdc_ip))
     try:
         image_utils.upload_volume(context, image_service, image_meta,
                                   self._attach_volume(volume, sdc_ip))
     finally:
         self._detach_volume(volume, sdc_ip)
Exemplo n.º 47
0
Arquivo: rbd.py Projeto: Jchuan/cinder
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     tmp_dir = self._image_conversion_dir()
     tmp_file = os.path.join(tmp_dir, volume.name + '-' + image_meta['id'])
     with fileutils.remove_path_on_error(tmp_file):
         args = [
             'rbd', 'export', '--pool', self.configuration.rbd_pool,
             volume.name, tmp_file
         ]
         args.extend(self._ceph_args())
         self._try_execute(*args)
         image_utils.upload_volume(context, image_service, image_meta,
                                   tmp_file)
     os.unlink(tmp_file)
Exemplo n.º 48
0
Arquivo: rbd.py Projeto: twigs/cinder
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        self._ensure_tmp_exists()

        tmp_dir = self.configuration.volume_tmp_dir or '/tmp'
        tmp_file = os.path.join(tmp_dir,
                                volume['name'] + '-' + image_meta['id'])
        with utils.remove_path_on_error(tmp_file):
            self._try_execute('rbd', 'export',
                              '--pool', self.configuration.rbd_pool,
                              volume['name'], tmp_file)
            image_utils.upload_volume(context, image_service,
                                      image_meta, tmp_file)
        os.unlink(tmp_file)
Exemplo n.º 49
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     LOG.info(
         _LI("ScaleIO copy_volume_to_image volume: %(vol)s image service: "
             "%(service)s image meta: %(meta)s."), {
                 'vol': volume,
                 'service': six.text_type(image_service),
                 'meta': six.text_type(image_meta)
             })
     try:
         image_utils.upload_volume(context, image_service, image_meta,
                                   self._sio_attach_volume(volume))
     finally:
         self._sio_detach_volume(volume)
Exemplo n.º 50
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy a  volume to a new image."""
     LOG.debug("Enter in copy image to volume for disco.")
     try:
         attach_detach_volume = (
             disco_attach_detach.AttachDetachDiscoVolume(
                 self.configuration))
         device_info = attach_detach_volume._attach_volume(volume)
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   device_info['path'])
     finally:
         attach_detach_volume._detach_volume(volume)
Exemplo n.º 51
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.debug(_('copy_volume_to_image %s.') % volume['name'])

        properties = utils.brick_get_connector_properties()
        attach_info = self._attach_volume(context, volume, properties)

        try:
            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      attach_info['device']['path'])
        finally:
            self._detach_volume(attach_info)
            self.terminate_connection(volume, properties)
Exemplo n.º 52
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     LOG.info(_LI(
         "ScaleIO copy_volume_to_image volume: %(vol)s image service: "
         "%(service)s image meta: %(meta)s."),
         {'vol': volume,
          'service': six.text_type(image_service),
          'meta': six.text_type(image_meta)})
     try:
         image_utils.upload_volume(context,
                                   image_service,
                                   image_meta,
                                   self._sio_attach_volume(volume))
     finally:
         self._sio_detach_volume(volume)
Exemplo n.º 53
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        disk_format = self._tgt_utils.get_supported_disk_format()
        temp_vhd_path = os.path.join(CONF.image_conversion_dir,
                                     str(image_meta['id']) + '.' + disk_format)

        try:
            with self._temporary_snapshot(volume['name']) as tmp_snap_name:
                # qemu-img cannot access VSS snapshots, for which reason it
                # must be exported first.
                self._tgt_utils.export_snapshot(tmp_snap_name, temp_vhd_path)
                image_utils.upload_volume(context, image_service, image_meta,
                                          temp_vhd_path, 'vhd')
        finally:
            fileutils.delete_if_exists(temp_vhd_path)
Exemplo n.º 54
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        disk_format = self._tgt_utils.get_supported_disk_format()
        temp_vhd_path = os.path.join(CONF.image_conversion_dir,
                                     str(image_meta['id']) + '.' + disk_format)

        try:
            with self._temporary_snapshot(volume.name) as tmp_snap_name:
                # qemu-img cannot access VSS snapshots, for which reason it
                # must be exported first.
                self._tgt_utils.export_snapshot(tmp_snap_name, temp_vhd_path)
                image_utils.upload_volume(context, image_service, image_meta,
                                          temp_vhd_path, 'vhd')
        finally:
            fileutils.delete_if_exists(temp_vhd_path)
Exemplo n.º 55
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
        connector = {'initiator': self._get_iscsi_initiator(),
                     'host': socket.gethostname()}

        iscsi_properties, volume_path = self._attach_volume(
            context, volume, connector)

        try:
            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      volume_path)
        finally:
            self.terminate_connection(volume, connector)
Exemplo n.º 56
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
        initiator = self._get_iscsi_initiator()
        connector = {}
        connector['initiator'] = initiator

        iscsi_properties, volume_path = self._attach_volume(
            context, volume, connector)

        try:
            image_utils.upload_volume(context,
                                      image_service,
                                      image_meta,
                                      volume_path)
        finally:
            self.terminate_connection(volume, connector)
Exemplo n.º 57
0
    def _copy_volume_to_image(self, context, volume, image_service,
                              image_meta):
        """Copy the volume to the specified image."""

        volume_format = self.get_volume_format(volume)
        if volume_format == DISK_FORMAT_PLOOP:
            with PloopDevice(self.local_path(volume),
                             execute=self._execute) as dev:
                image_utils.upload_volume(context,
                                          image_service,
                                          image_meta,
                                          dev,
                                          volume_format='raw')
        else:
            super(VZStorageDriver,
                  self)._copy_volume_to_image(context, volume, image_service,
                                              image_meta)
Exemplo n.º 58
0
 def copy_volume_to_image(self, context, volume, image_service, image_meta):
     """Copy the volume to the specified image."""
     LOG.info(
         _LI("ScaleIO copy_volume_to_image volume: %(vol)s image service: "
             "%(service)s image meta: %(meta)s."), {
                 'vol': volume,
                 'service': six.text_type(image_service),
                 'meta': six.text_type(image_meta)
             })
     properties = utils.brick_get_connector_properties()
     sdc_ip = properties['ip']
     LOG.debug("SDC ip is: {0}".format(sdc_ip))
     try:
         image_utils.upload_volume(context, image_service, image_meta,
                                   self._sio_attach_volume(volume, sdc_ip))
     finally:
         self._sio_detach_volume(volume, sdc_ip)
Exemplo n.º 59
0
    def _copy_volume_to_image(self, context, volume, image_service,
                              image_meta):
        """Copy the volume to the specified image."""

        volume_format = self.get_volume_format(volume)
        if volume_format == DISK_FORMAT_PLOOP:
            with PloopDevice(self.local_path(volume),
                             execute=self._execute) as dev:
                image_utils.upload_volume(context,
                                          image_service,
                                          image_meta,
                                          dev,
                                          volume_format='raw')
        else:
            super(VZStorageDriver, self)._copy_volume_to_image(context, volume,
                                                               image_service,
                                                               image_meta)