示例#1
0
文件: glusterfs.py 项目: licyh/cinder
    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)
示例#2
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))
示例#3
0
 def copy_image_to_volume(self, context, volume, image_service, image_id):
     with image_utils.temporary_file() as tmp:
         image_utils.fetch_verify_image(context, image_service,
                                        image_id, tmp)
     image_utils.fetch_to_raw(context,
                              image_service,
                              image_id,
                              tmp,
                              self.configuration.volume_dd_blocksize,
                              size=volume['size'])
示例#4
0
    def copy_image_to_volume(self, context, volume, image_service, image_id):
        with image_utils.temporary_file() as tmp:
            # (wenhao): we don't need to convert to raw for sheepdog.
            image_utils.fetch_verify_image(context, image_service, image_id, tmp)

            # remove the image created by import before this function.
            # see volume/drivers/manager.py:_create_volume
            self.client.delete(volume.name)
            # convert and store into sheepdog
            image_utils.convert_image(tmp, self.client.local_path(volume), "raw")
            self.client.resize(volume.name, volume.size)
示例#5
0
    def test_file_unlinked(self):
        mox = self.mox
        mox.StubOutWithMock(image_utils, 'create_temporary_file')
        mox.StubOutWithMock(image_utils.os, 'unlink')

        image_utils.create_temporary_file().AndReturn('somefile')
        image_utils.os.unlink('somefile')

        mox.ReplayAll()

        with image_utils.temporary_file():
            pass
示例#6
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        image_id = image_meta["id"]
        with image_utils.temporary_file() as tmp:
            # image_utils.convert_image doesn't support "sheepdog:" source,
            # so we use the qemu-img directly.
            # Sheepdog volume is always raw-formatted.
            cmd = ("qemu-img", "convert", "-f", "raw", "-t", "none", "-O", "raw", self.client.local_path(volume), tmp)
            self._try_execute(*cmd)

            with open(tmp, "rb") as image_file:
                image_service.update(context, image_id, {}, image_file)
示例#7
0
    def test_file_unlinked(self):
        mox = self.mox
        mox.StubOutWithMock(image_utils, 'create_temporary_file')
        mox.StubOutWithMock(fileutils, 'delete_if_exists')

        image_utils.create_temporary_file().AndReturn('somefile')
        fileutils.delete_if_exists('somefile')

        mox.ReplayAll()

        with image_utils.temporary_file():
            pass
示例#8
0
    def copy_image_to_volume(self, context, volume, image_service, image_id):
        with image_utils.temporary_file() as tmp:
            # (wenhao): we don't need to convert to raw for sheepdog.
            image_utils.fetch_verify_image(context, image_service,
                                           image_id, tmp)

            # remove the image created by import before this function.
            # see volume/drivers/manager.py:_create_volume
            self._delete(volume)
            # convert and store into sheepdog
            image_utils.convert_image(tmp, 'sheepdog:%s' % volume['name'],
                                      'raw')
            self._resize(volume)
示例#9
0
    def copy_image_to_volume(self, context, volume, image_service, image_id):
        with image_utils.temporary_file() as tmp:
            # (wenhao): we don't need to convert to raw for sheepdog.
            image_utils.fetch_verify_image(context, image_service, image_id,
                                           tmp)

            # remove the image created by import before this function.
            # see volume/drivers/manager.py:_create_volume
            self.client.delete(volume.name)
            # convert and store into sheepdog
            image_utils.convert_image(tmp, self.client.local_path(volume),
                                      'raw')
            self.client.resize(volume.name, volume.size)
示例#10
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        image_id = image_meta['id']
        with image_utils.temporary_file() as tmp:
            # image_utils.convert_image doesn't support "sheepdog:" source,
            # so we use the qemu-img directly.
            # Sheepdog volume is always raw-formatted.
            cmd = ('qemu-img', 'convert', '-f', 'raw', '-t', 'none', '-O',
                   'raw', self.local_path(volume), tmp)
            self._try_execute(*cmd)

            with open(tmp, 'rb') as image_file:
                image_service.update(context, image_id, {}, image_file)
示例#11
0
 def copy_image_to_volume(self, context, volume, image_service, image_id):
     """Fetch the image from image_service and create a volume using it."""
     # Convert to VHD and file back to VHD
     vhd_type = self.utils.get_supported_vhd_type()
     with image_utils.temporary_file(suffix=".vhd") as tmp:
         volume_path = self.local_path(volume)
         image_utils.fetch_to_vhd(context, image_service, image_id, tmp, self.configuration.volume_dd_blocksize)
         # The vhd must be disabled and deleted before being replaced with
         # the desired image.
         self.utils.change_disk_status(volume["name"], False)
         os.unlink(volume_path)
         self.vhdutils.convert_vhd(tmp, volume_path, vhd_type)
         self.vhdutils.resize_vhd(volume_path, volume["size"] << 30)
         self.utils.change_disk_status(volume["name"], True)
示例#12
0
 def copy_image_to_volume(self, context, volume, image_service, image_id):
     """Fetch the image from image_service and create a volume using it."""
     # Convert to VHD and file back to VHD
     vhd_type = self.utils.get_supported_vhd_type()
     with image_utils.temporary_file(suffix='.vhd') as tmp:
         volume_path = self.local_path(volume)
         image_utils.fetch_to_vhd(context, image_service, image_id, tmp,
                                  self.configuration.volume_dd_blocksize)
         # The vhd must be disabled and deleted before being replaced with
         # the desired image.
         self.utils.change_disk_status(volume['name'], False)
         os.unlink(volume_path)
         self.vhdutils.convert_vhd(tmp, volume_path, vhd_type)
         self.vhdutils.resize_vhd(volume_path, volume['size'] << 30)
         self.utils.change_disk_status(volume['name'], True)
示例#13
0
    def copy_image_to_volume(self, context, volume, image_service, image_id):
        with image_utils.temporary_file() as tmp:
            # (wenhao): we don't need to convert to raw for sheepdog.
            image_utils.fetch_verify_image(context, image_service, image_id,
                                           tmp)

            # remove the image created by import before this function.
            # see volume/drivers/manager.py:_create_volume
            self.client.delete(volume.name)
            # convert and store into sheepdog
            image_utils.convert_image(
                tmp, 'sheepdog:%(addr)s:%(port)d:%(name)s' % {
                    'addr': CONF.sheepdog_store_address,
                    'port': CONF.sheepdog_store_port,
                    'name': volume['name']
                }, 'raw')
            self.client.resize(volume.name, volume.size)
示例#14
0
文件: sheepdog.py 项目: Third9/cinder
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        image_id = image_meta['id']
        with image_utils.temporary_file() as tmp:
            # image_utils.convert_image doesn't support "sheepdog:" source,
            # so we use the qemu-img directly.
            # Sheepdog volume is always raw-formatted.
            cmd = ('qemu-img',
                   'convert',
                   '-f', 'raw',
                   '-t', 'none',
                   '-O', 'raw',
                   self.client.local_path(volume),
                   tmp)
            self._try_execute(*cmd)

            with open(tmp, 'rb') as image_file:
                image_service.update(context, image_id, {}, image_file)
示例#15
0
    def copy_image_to_volume(self, context, volume, image_service, image_id):
        with image_utils.temporary_file() as tmp:
            # (wenhao): we don't need to convert to raw for sheepdog.
            image_utils.fetch_verify_image(context, image_service,
                                           image_id, tmp)

            # remove the image created by import before this function.
            # see volume/drivers/manager.py:_create_volume
            self.client.delete(volume.name)
            # convert and store into sheepdog
            image_utils.convert_image(
                tmp,
                'sheepdog:%(addr)s:%(port)d:%(name)s' % {
                    'addr': CONF.sheepdog_store_address,
                    'port': CONF.sheepdog_store_port,
                    'name': volume['name']},
                'raw')
            self.client.resize(volume.name, volume.size)
示例#16
0
 def copy_image_to_volume(self, context, volume, image_service, image_id):
     """Fetch the image from image_service and create a volume using it."""
     # Convert to VHD and file back to VHD
     if (CONF.image_conversion_dir and not
             os.path.exists(CONF.image_conversion_dir)):
         os.makedirs(CONF.image_conversion_dir)
     with image_utils.temporary_file(suffix='.vhd') as tmp:
         volume_path = self.local_path(volume)
         image_utils.fetch_to_vhd(context, image_service, image_id, tmp,
                                  self.configuration.volume_dd_blocksize)
         # The vhd must be disabled and deleted before being replaced with
         # the desired image.
         self.utils.change_disk_status(volume['name'], False)
         os.unlink(volume_path)
         self.utils.convert_vhd(tmp, volume_path,
                                constants.VHD_TYPE_FIXED)
         self.utils.resize_vhd(volume_path,
                               volume['size'] << 30)
         self.utils.change_disk_status(volume['name'], True)
示例#17
0
    def fetch_to_vhd(self, context, image_service,
                 image_id, dest,
                 user_id=None, project_id=None):
        if (CONF.image_conversion_dir and not
                os.path.exists(CONF.image_conversion_dir)):
            os.makedirs(CONF.image_conversion_dir)

        with image_utils.temporary_file() as tmp:
            LOG.debug("Downloading image %s was to tmp dest: " ,image_id)
            image_utils.fetch(context, image_service, image_id, tmp, user_id,
                              project_id)

            LOG.debug("Downloading DONE %s was to tmp dest: " ,image_id)

            data = self.qemu_img_info(tmp)
            fmt = data.file_format
            if fmt is None:
                raise exception.ImageUnacceptable(
                    reason=_("'qemu-img info' parsing failed."),
                    image_id=image_id)

            backing_file = data.backing_file
            if backing_file is not None:
                raise exception.ImageUnacceptable(
                    image_id=image_id,
                    reason=_("fmt=%(fmt)s backed by:"
                             "%(backing_file)s") % {
                                 'fmt': fmt,
                                 'backing_file': backing_file,
                             })

            if 'vpc' not in fmt:
                self.convert_image(tmp, dest, 'vpc')
            else:
                self.copy_vhd_disk(tmp, dest)

            data = self.qemu_img_info(dest)
            if data.file_format != "vpc":
                raise exception.ImageUnacceptable(
                    image_id=image_id,
                    reason=_("Converted to vhd, but format is now %s") %
                    data.file_format)
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image."""
        # begin added by liuling
        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')
        image_name = image_meta.get('name')
        full_url = None
        if container_format == 'vgw_url':
            LOG.debug('get the vgw url')
            #vgw_url = CONF.vgw.vgw_url.get(container_format)
            kwargs = {
                'auth_url': CONF.keystone_authtoken.keystone_auth_url,
                'tenant_name': CONF.keystone_authtoken.tenant_name,
                'username': CONF.keystone_authtoken.user_name,
                'password': CONF.keystone_authtoken.admin_password,
                'insecure': True
            }
            keystoneclient = kc.Client(**kwargs)

            vgw_url = self._get_management_url(keystoneclient,
                                               image_name,
                                               service_type='v2v')
            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())))
            # end added by liuling
        else:
            image_utils.upload_volume(context, image_service, image_meta,
                                      self.local_path(volume))
示例#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')
     image_name = image_meta.get('name')
     full_url=None
     if container_format == 'vgw_url':
         LOG.debug('get the vgw url')
         #vgw_url = CONF.vgw.vgw_url.get(container_format)
         kwargs = {
                 'auth_url': CONF.keystone_authtoken.keystone_auth_url,
                 'tenant_name':CONF.keystone_authtoken.tenant_name,
                 'username': CONF.keystone_authtoken.user_name,
                 'password': CONF.keystone_authtoken.admin_password,
                 'insecure': True
             }
         keystoneclient = kc.Client(**kwargs)
        
          
         vgw_url = self._get_management_url(keystoneclient,image_name, service_type='v2v')
         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))
示例#20
0
    def copy_image_to_volume(self, context, volume, image_service, image_id):
        """Fetch the image from image_service and write it to the volume."""

        img_cache_volume = {'name': 'img-%s' % image_id}
        img_cache_snapshot = {'volume_name': img_cache_volume['name'],
                              'name': 'snap'}

        if self._list_snapshots(volume):
            # If the volume has snapshots, there is no efficient way to replace
            # the contents. Do things the inefficient way.
            image_utils.fetch_to_raw(context, image_service, image_id,
                                     self.local_path(volume),
                                     self.configuration.volume_dd_blocksize,
                                     size=volume['size'])

        else:

            if not self.snapshot_exists(img_cache_snapshot):
                with image_utils.temporary_file() as tmp:
                    image_utils.fetch_verify_image(context, image_service,
                                                   image_id, tmp)

                    qemu_info = image_utils.qemu_img_info(tmp)
                    virtual_size_gb = math.ceil(
                        qemu_info.virtual_size / (1024.0 ** 3))
                    img_cache_volume['size'] = virtual_size_gb

                    self.create_volume(img_cache_volume)

                    image_utils.convert_image(
                        tmp, self.local_path(img_cache_volume), 'raw', None,
                        sparse=64 * 1024)

                self.create_snapshot(img_cache_snapshot)

            self.delete_volume(volume)
            self.create_volume_from_snapshot(volume, img_cache_snapshot)
            self.extend_volume(volume, volume['size'])
示例#21
0
文件: remotefs.py 项目: nash-x/hws
    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, volume["name"])
        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)
示例#22
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Creates glance image from volume."""
        LOG.debug('Copying volume %(volume_name)s to image %(image_name)s.',
                  {'volume_name': volume['display_name'],
                   'image_name': image_meta.get('name')})

        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')
        if container_format in VGW_URLS:
            # attach the volume to vgw vm
            disk_ref, the_vapp = self._attach_volume_to_vgw(volume)

            try:
                # use ssh client connect to vgw_host and
                # copy image file to volume
                self._copy_volume_to_file_to_vgw(image_meta)
            finally:
                # detach volume from vgw and
                self._detach_disk_from_vm(the_vapp, disk_ref)
            # create an empty file to glance
            with image_utils.temporary_file() as tmp:
                image_utils.upload_volume(context,
                                          image_service,
                                          image_meta,
                                          tmp)

            LOG.error('end time of copy_volume_to_image is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))

        else:
            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')

                # timeout = IMAGE_TRANSFER_TIMEOUT_SECS
                # util.start_transfer(context, timeout, read_file_handle, file_size,
                #          image_service=image_service, image_id=image_meta['id'],
                #         image_meta=image_meta)
            _unused()
示例#23
0
 def sut():
     with image_utils.temporary_file():
         raise Exception()
示例#24
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Creates glance image from volume."""

        def _delete_vapp():
            self._vcloud_client.delete_vapp(clone_vapp_name)

        def _detach_disks_to_vm():
            for attached_disk_name in attached_disk_names:
                result, disk_ref = self._vcloud_client.get_disk_ref(attached_disk_name)
                if result:
                    self._vcloud_client.detach_disk_from_vm(clone_vapp_name, disk_ref)

        def _power_off_vapp():
            self._vcloud_client.power_off_vapp(clone_vapp_name)

        undo_mgr = util.UndoManager()
        attached_disk_names = []

        try:
            LOG.info('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')
            if container_format in VGW_URLS:
                # attach the volume to vgw vm
                disk_ref, vapp_name = self._attach_volume_to_vgw(volume)

                try:
                    # use ssh client connect to vgw_host and  copy image file to volume
                    self._copy_volume_to_file_to_vgw(image_meta)
                finally:
                    self._vcloud_client.detach_disk_from_vm(vapp_name, disk_ref)

                # create an empty file to glance
                with image_utils.temporary_file() as tmp:
                    image_utils.upload_volume(context,
                                              image_service,
                                              image_meta,
                                              tmp)
            elif container_format == constants.HYBRID_VM:
                volume_name = volume['display_name']
                vcloud_volume_name = self._get_vcloud_volume_name(volume['id'], volume_name)

                result,disk_ref = self._vcloud_client.get_disk_ref(vcloud_volume_name)
                if not result:
                    msg = 'can not find volume %s in vcloud!' %  vcloud_volume_name
                    LOG.error(msg)
                    raise exception.CinderException(msg)

                if volume['volume_attachment']:
                    msg = 'copy volume to image not support attached volume!'
                    LOG.error(msg)
                    raise exception.CinderException(msg)

                #NOTE(nkapotoxin): create vapp with vapptemplate
                network_names = [CONF.vcloud.provider_tunnel_network_name, CONF.vcloud.provider_base_network_name]
                network_configs = self._vcloud_client.get_network_configs(network_names)

                # create vapp
                clone_vapp_name = 'server@%s' % image_meta['id']
                clone_vapp = self._vcloud_client.create_vapp(clone_vapp_name, CONF.vcloud.base_image_id, network_configs)

                undo_mgr.undo_with(_delete_vapp)
                LOG.debug("Create clone vapp %s successful" % clone_vapp_name)

                # generate the network_connection
                network_connections = self._vcloud_client.get_network_connections(clone_vapp, network_names)

                # update network
                self._vcloud_client.update_vms_connections(clone_vapp, network_connections)

                # update vm specification
                #self._vcloud_client.modify_vm_cpu(clone_vapp, instance.get_flavor().vcpus)
                #self._vcloud_client.modify_vm_memory(clone_vapp, instance.get_flavor().memory_mb)
                LOG.debug("Config vapp %s successful" % clone_vapp_name)

                if self._vcloud_client.attach_disk_to_vm(clone_vapp_name, disk_ref):
                    attached_disk_names.append(vcloud_volume_name)
                    undo_mgr.undo_with(_detach_disks_to_vm)
                    LOG.debug("Volume %s attached to: %s", vcloud_volume_name, clone_vapp_name)

                # power on it
                self._vcloud_client.power_on_vapp(clone_vapp_name)
                undo_mgr.undo_with(_power_off_vapp)

                vapp_ip = self.get_vapp_ip(clone_vapp_name)
                client = Client(vapp_ip, CONF.vcloud.hybrid_service_port)
                self._wait_hybrid_service_up(vapp_ip, CONF.vcloud.hybrid_service_port)
                LOG.debug("vapp %s(ip: %s) hybrid service has been up", clone_vapp_name, vapp_ip)

                LOG.debug('begin time of create image is %s' % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
                task = client.create_image(image_meta['name'], image_meta['id'])
                while task['code'] == client_constants.TASK_DOING:
                    eventlet.greenthread.sleep(10)
                    task = client.query_task(task)

                if task['code'] != client_constants.TASK_SUCCESS:
                    LOG.error(task['message'])
                    raise exception.CinderException(task['message'])
                else:
                    LOG.debug('end time of create image is %s' % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

                image_info = client.image_info(image_meta['name'], image_meta['id'])
                if not image_info:
                    LOG.error('cannot get image info')
                    raise exception.CinderException('cannot get image info')

                LOG.debug('begin time of image_utils upload_volume %s' % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
                with image_utils.temporary_file() as tmp:
                    with fileutils.file_open(tmp, 'wb+') as f:
                        f.truncate(image_info['size'])
                        image_utils.upload_volume(context,
                                                  image_service,
                                                  image_meta,
                                                  tmp,
                                                  volume_format=image_meta['disk_format'])
                LOG.debug('end time of image_utils upload_volume %s' % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))

                undo_mgr.cancel_undo(_power_off_vapp)
                self._vcloud_client.power_off_vapp(clone_vapp_name)

                attached_disk_names.remove(vcloud_volume_name)
                self._vcloud_client.detach_disk_from_vm(clone_vapp_name, disk_ref)

                undo_mgr.cancel_undo(_delete_vapp)
                self._vcloud_client.delete_vapp(clone_vapp_name)

            LOG.info('end time of copy_volume_to_image is %s' %
                  (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
        except Exception as e:
            msg = _("Failed to copy volume to image reason %s, rolling back") % e
            LOG.error(msg)
            undo_mgr.rollback_and_reraise(msg=msg)
示例#25
0
文件: __init__.py 项目: nash-x/hws
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        container_format = image_meta.get('container_format')
        #if container_format == 'vgw_url':
        if container_format == 'bare':
            try:
                # 1.get the hws volume id
                cascaded_volume_id = volume['id']
                hws_volume_id = self.db_manager.get_cascaded_volume_id(cascaded_volume_id)
                if not hws_volume_id:
                    msg = 'get hws volume id error, cascaded id: %s' % cascaded_volume_id
                    LOG.error(msg)
                    raise Exception('get hws volume id error')
                # 2. get the hws_volume status
                volume_detail_rsp = self._get_volume_detail(hws_volume_id)
                status = volume_detail_rsp['body']['volume']['status']
                # attachments = volume_detail_rsp['body']['volume']['attachments']
                # attach_num = len(attachments)
                # origin_instance_id = None
                # attach_back = False
                # 3. detach volume from origin instance
                # if status == 'in-use':
                #     if attach_num != 1:
                #         msg = 'hws_v2v: get attachments info error, num: %s' % attach_num
                #         LOG.error(msg)
                #         raise Exception(msg)
                #     origin_instance_id = attachments[0]['server_id']
                #     # volume can only be detached when sever stop
                #     self._stop_server(origin_instance_id)
                #     self._detach_volume(origin_instance_id, hws_volume_id)
                #     attach_back = True
                #     volume_detail_rsp = self._get_volume_detail(hws_volume_id)
                #     status = volume_detail_rsp['body']['status']

                # 4. attach volume to hws v2v gateway host
                if status != 'available':
                    msg = 'attach volume to local v2v gateway host error, status : %s, cascaded_volume_id: %s, ' \
                          'hws_volume_id %s' % (status, cascaded_volume_id, hws_volume_id)
                    LOG.error(msg)
                    raise Exception('attach volume to local v2v gateway failed')
                hws_vgw_instance_id = CONF.hws_vgw.hws_instance_id
                # if not hws_vgw_instance_id:
                #     LOG.error(
                #         'hws_v2v: get cascaded v2v gateway instance id error: %s' % CONF.hws_vgw.cascaded_instance_id)
                #     raise Exception('hws_v2v: get cascaded v2v gateway instance error.')
                dev_name = self._get_instance_next_devname(hws_vgw_instance_id)
                self._attach_volume(hws_vgw_instance_id, hws_volume_id, dev_name)
                # 5. copy volume to file
                self._copy_volume_to_file(image_meta, dev_name)

                # 6. copy file to remote v2v gateway
                # self._copy_file_to_remote_vgw(image_meta)
                # 7. 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)
                # 8. detach volume from hws v2v gateway
                self._stop_server(hws_vgw_instance_id)
                self._detach_volume(hws_vgw_instance_id, hws_volume_id)
                self._power_on(hws_vgw_instance_id)
            finally:
                attach_back = True
示例#26
0
 def sut():
     with image_utils.temporary_file():
         raise test.TestingException()
示例#27
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        container_format = image_meta.get('container_format')
        #if container_format == 'vgw_url':
        if container_format == 'bare':
            try:
                # 1.get the hws volume id
                cascaded_volume_id = volume['id']
                hws_volume_id = self.db_manager.get_cascaded_volume_id(
                    cascaded_volume_id)
                if not hws_volume_id:
                    msg = 'get hws volume id error, cascaded id: %s' % cascaded_volume_id
                    LOG.error(msg)
                    raise Exception('get hws volume id error')
                # 2. get the hws_volume status
                volume_detail_rsp = self._get_volume_detail(hws_volume_id)
                status = volume_detail_rsp['body']['volume']['status']
                # attachments = volume_detail_rsp['body']['volume']['attachments']
                # attach_num = len(attachments)
                # origin_instance_id = None
                # attach_back = False
                # 3. detach volume from origin instance
                # if status == 'in-use':
                #     if attach_num != 1:
                #         msg = 'hws_v2v: get attachments info error, num: %s' % attach_num
                #         LOG.error(msg)
                #         raise Exception(msg)
                #     origin_instance_id = attachments[0]['server_id']
                #     # volume can only be detached when sever stop
                #     self._stop_server(origin_instance_id)
                #     self._detach_volume(origin_instance_id, hws_volume_id)
                #     attach_back = True
                #     volume_detail_rsp = self._get_volume_detail(hws_volume_id)
                #     status = volume_detail_rsp['body']['status']

                # 4. attach volume to hws v2v gateway host
                if status != 'available':
                    msg = 'attach volume to local v2v gateway host error, status : %s, cascaded_volume_id: %s, ' \
                          'hws_volume_id %s' % (status, cascaded_volume_id, hws_volume_id)
                    LOG.error(msg)
                    raise Exception(
                        'attach volume to local v2v gateway failed')
                hws_vgw_instance_id = CONF.hws_vgw.hws_instance_id
                # if not hws_vgw_instance_id:
                #     LOG.error(
                #         'hws_v2v: get cascaded v2v gateway instance id error: %s' % CONF.hws_vgw.cascaded_instance_id)
                #     raise Exception('hws_v2v: get cascaded v2v gateway instance error.')
                dev_name = self._get_instance_next_devname(hws_vgw_instance_id)
                self._attach_volume(hws_vgw_instance_id, hws_volume_id,
                                    dev_name)
                # 5. copy volume to file
                self._copy_volume_to_file(image_meta, dev_name)

                # 6. copy file to remote v2v gateway
                # self._copy_file_to_remote_vgw(image_meta)
                # 7. 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)
                # 8. detach volume from hws v2v gateway
                self._stop_server(hws_vgw_instance_id)
                self._detach_volume(hws_vgw_instance_id, hws_volume_id)
                self._power_on(hws_vgw_instance_id)
            finally:
                attach_back = True
示例#28
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        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")
        image_name = image_meta.get("name")
        file_name = image_meta.get("id")
        if container_format == "vgw_url":
            LOG.debug("get the vgw url")
            # vgw_url = CONF.vgw.vgw_url.get(container_format)
            kwargs = {
                "auth_url": CONF.keystone_authtoken.keystone_auth_url,
                "tenant_name": CONF.keystone_authtoken.tenant_name,
                "username": CONF.keystone_authtoken.user_name,
                "password": CONF.keystone_authtoken.admin_password,
                "insecure": True,
            }
            keystoneclient = kc.Client(**kwargs)

            vgw_url = self._get_management_url(keystoneclient, image_name, service_type="v2v")

            # vgw_url = 'http://162.3.125.52:9999/'
            volume_id = volume["id"]

            # 1.get the provider_volume at provider cloud
            provider_volume_id = self._get_provider_volumeid_from_volume(volume)
            if not provider_volume_id:
                LOG.error("get provider_volume_id of volume %s error" % volume_id)
                raise exception_ex.ProviderVolumeNotFound(volume_id=volume_id)
            provider_volume = self._get_provider_volume(provider_volume_id)
            if not provider_volume:
                LOG.error("get provider_volume of volume %s at provider cloud error" % volume_id)
                raise exception_ex.ProviderVolumeNotFound(volume_id=volume_id)

            origin_provider_volume_state = provider_volume.extra.get("attachment_status")

            LOG.error("the origin_provider_volume_info is %s" % str(provider_volume.__dict__))
            origin_attach_node_id = None
            origin_device_name = None
            # 2.judge if the volume is available
            if origin_provider_volume_state is not None:
                origin_attach_node_id = provider_volume.extra["instance_id"]
                origin_device_name = provider_volume.extra["device"]
                self.adpter.detach_volume(provider_volume)
                time.sleep(1)
                retry_time = 90
                provider_volume = self._get_provider_volume(provider_volume_id)
                LOG.error("the after detach _volume_info is %s" % str(provider_volume.__dict__))
                while retry_time > 0:
                    if provider_volume and provider_volume.extra.get("attachment_status") is None:
                        break
                    else:
                        time.sleep(2)
                        provider_volume = self._get_provider_volume(provider_volume_id)
                        LOG.error(
                            "the after detach _volume_info is %s,the retry_time is %s"
                            % (str(provider_volume.__dict__), str(retry_time))
                        )
                        retry_time = retry_time - 1
            # 3.attach the volume to vgw host
            try:
                # 3.1 get the vgw host
                vgw_host = self._get_provider_node(self.configuration.cgw_host_id)
                if not vgw_host:
                    raise exception_ex.VgwHostNotFound(Vgw_id=self.configuration.cgw_host_id)
                device_name = self._get_next_device_name(vgw_host)
                LOG.error("**********************************************")
                LOG.error("the volume status %s" % provider_volume.state)
                self.adpter.attach_volume(vgw_host, provider_volume, device_name)
                # query volume status
                time.sleep(1)
                retry_time = 120
                provider_volume = self._get_provider_volume(provider_volume_id)
                while retry_time > 0:
                    if provider_volume and provider_volume.extra.get("attachment_status") == "attached":
                        break
                    else:
                        time.sleep(2)
                        provider_volume = self._get_provider_volume(provider_volume_id)
                        retry_time = retry_time - 1

            except Exception as e:
                raise e
            time.sleep(5)
            conn = rpyc.connect(self.configuration.cgw_host_ip, int(CONF.vgw.rpc_service_port))
            LOG.error(
                "begin time of copy_volume_to_file is %s" % (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
            )
            full_file_path = conn.root.copy_volume_to_file(device_name, file_name, CONF.vgw.store_file_dir)
            LOG.error("end time of copy_volume_to_image is %s" % (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            # todo exception occured clean env
            if not full_file_path:
                self.adpter.detach_volume(provider_volume)
                conn.close()
                raise exception_ex.ProviderExportVolumeError(volume_id=volume_id)
            LOG.error("begin time of push_file_to_vgw is %s" % (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            push_file_result = conn.root.exposed_push_file_to_vgw(full_file_path, vgw_url)
            LOG.error("end time of push_file_to_vgw is %s" % (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            if not push_file_result:
                LOG.error("post file file %s  to %s failed" % (push_file_result, vgw_url))
                self.adpter.detach_volume(provider_volume)
                conn.close()
                raise exception_ex.ProviderExportVolumeError(volume_id=volume_id)
            conn.close()
            # 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)
            # 4.detach form vgw
            self.adpter.detach_volume(provider_volume)
            time.sleep(1)
            retry_time = 120
            provider_volume = self._get_provider_volume(provider_volume_id)
            while retry_time > 0:
                if provider_volume and provider_volume.extra.get("attachment_status") is None:
                    break
                else:
                    time.sleep(2)
                    provider_volume = self._get_provider_volume(provider_volume_id)
                    retry_time = retry_time - 1
            LOG.error("**********************************************")
            LOG.error("the volume status %s" % provider_volume.state)
            # attach the volume back
            if origin_provider_volume_state is not None:
                origin_attach_node = self._get_provider_node(origin_attach_node_id)

                self.adpter.attach_volume(origin_attach_node, provider_volume, origin_device_name)

        else:
            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)
        LOG.error("end time of copy_volume_to_image is %s" % (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
示例#29
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta): 
        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')
        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)
            #vgw_url = 'http://162.3.125.52:9999/'
            volume_id = volume['id']
 
            #1.get the provider_volume at provider cloud  
            provider_volume_id = self._get_provider_volumeid_from_volume(volume)
            if not provider_volume_id:
                LOG.error('get provider_volume_id of volume %s error' % volume_id) 
                raise exception_ex.ProviderVolumeNotFound(volume_id=volume_id)
            provider_volume=self._get_provider_volume(provider_volume_id)
            if not provider_volume:
                LOG.error('get provider_volume of volume %s at provider cloud error' % volume_id) 
                raise exception_ex.ProviderVolumeNotFound(volume_id=volume_id)
            
            origin_provider_volume_state= provider_volume.extra.get('attachment_status')
            origin_attach_node_id = None
            origin_device_name=None
            #2.judge if the volume is available
            if origin_provider_volume_state is not None:
                origin_attach_node_id = provider_volume.extra['instance_id']
                origin_device_name = provider_volume.extra['device']
                self.adpter.detach_volume(provider_volume)
                time.sleep(1)
                retry_time = 50
                provider_volume=self._get_provider_volume(provider_volume_id)
                while retry_time > 0:
                    if provider_volume and provider_volume.extra.get('attachment_status') is None:
                        break
                    else:
                        time.sleep(1)
                        provider_volume=self._get_provider_volume(provider_volume_id)
                        retry_time = retry_time-1
            #3.attach the volume to vgw host
            try:
                #3.1 get the vgw host
                vgw_host= self._get_provider_node(self.configuration.cgw_host_id)
                if not vgw_host:
                    raise exception_ex.VgwHostNotFound(Vgw_id=self.configuration.cgw_host_id)
                device_name=self._get_next_device_name(vgw_host)
                LOG.error('**********************************************')
                LOG.error('the volume status %s' %provider_volume.state)
                self.adpter.attach_volume(vgw_host, provider_volume,
                                       device_name)
                #query volume status
                time.sleep(1)
                retry_time = 120
                provider_volume=self._get_provider_volume(provider_volume_id)
                while retry_time > 0:
                    if provider_volume and provider_volume.extra.get('attachment_status') =='attached':
                        break
                    else:
                        time.sleep(1)
                        provider_volume=self._get_provider_volume(provider_volume_id)
                        retry_time = retry_time-1
                
            except Exception as e:
                raise e
            time.sleep(5)           
            conn=rpyc.connect(self.configuration.cgw_host_ip,int(CONF.vgw.rpc_service_port))
            LOG.error('begin time of copy_volume_to_file is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            full_file_path = conn.root.copy_volume_to_file(device_name,file_name,CONF.vgw.store_file_dir)
            LOG.error('end time of copy_volume_to_image is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            #todo exception occured clean env
            if not full_file_path:
                self.adpter.detach_volume(provider_volume)
                conn.close()
                raise exception_ex.ProviderExportVolumeError(volume_id=volume_id)
            LOG.error('begin time of push_file_to_vgw is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            push_file_result =conn.root.exposed_push_file_to_vgw(full_file_path,vgw_url)
            LOG.error('end time of push_file_to_vgw is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            if not push_file_result:
                LOG.error('post file file %s  to %s failed' %(push_file_result,vgw_url))
                self.adpter.detach_volume(provider_volume)
                conn.close()
                raise exception_ex.ProviderExportVolumeError(volume_id=volume_id)
            conn.close()
            #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)
            #4.detach form vgw
            self.adpter.detach_volume(provider_volume)
            time.sleep(1)
            retry_time = 120
            provider_volume=self._get_provider_volume(provider_volume_id)
            while retry_time > 0:
                if provider_volume and provider_volume.extra.get('attachment_status') is None:
                    break
                else:
                    time.sleep(1)
                    provider_volume=self._get_provider_volume(provider_volume_id)
                    retry_time = retry_time-1
            LOG.error('**********************************************')
            LOG.error('the volume status %s' %provider_volume.state)       
            #attach the volume back         
            if origin_provider_volume_state is not None:
                origin_attach_node = self._get_provider_node(origin_attach_node_id)
                 
                self.adpter.attach_volume(origin_attach_node, provider_volume,
                                           origin_device_name)
                
        else:
            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)
        LOG.error('end time of copy_volume_to_image is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
示例#30
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Creates glance image from volume."""
        LOG.debug(
            'Copying volume %(volume_name)s to image %(image_name)s.', {
                'volume_name': volume['display_name'],
                'image_name': image_meta.get('name')
            })

        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')
        if container_format in VGW_URLS:
            # attach the volume to vgw vm
            disk_ref, the_vapp = self._attach_volume_to_vgw(volume)

            try:
                # use ssh client connect to vgw_host and
                # copy image file to volume
                self._copy_volume_to_file_to_vgw(image_meta)
            finally:
                # detach volume from vgw and
                self._detach_disk_from_vm(the_vapp, disk_ref)
            # create an empty file to glance
            with image_utils.temporary_file() as tmp:
                image_utils.upload_volume(context, image_service, image_meta,
                                          tmp)

            LOG.error('end time of copy_volume_to_image is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))

        else:

            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')

                # timeout = IMAGE_TRANSFER_TIMEOUT_SECS
                # util.start_transfer(context, timeout, read_file_handle, file_size,
                #          image_service=image_service, image_id=image_meta['id'],
                #         image_meta=image_meta)

            _unused()
示例#31
0
 def sut():
     with image_utils.temporary_file():
         raise test.TestingException()
示例#32
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        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')
        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)
            #vgw_url = 'http://162.3.125.52:9999/'
            volume_id = volume['id']

            #1.get the provider_volume at provider cloud
            provider_volume_id = self._get_provider_volumeid_from_volume(
                volume)
            if not provider_volume_id:
                LOG.error('get provider_volume_id of volume %s error' %
                          volume_id)
                raise exception_ex.ProviderVolumeNotFound(volume_id=volume_id)
            provider_volume = self._get_provider_volume(provider_volume_id)
            if not provider_volume:
                LOG.error(
                    'get provider_volume of volume %s at provider cloud error'
                    % volume_id)
                raise exception_ex.ProviderVolumeNotFound(volume_id=volume_id)

            origin_provider_volume_state = provider_volume.extra.get(
                'attachment_status')
            origin_attach_node_id = None
            origin_device_name = None
            #2.judge if the volume is available
            if origin_provider_volume_state is not None:
                origin_attach_node_id = provider_volume.extra['instance_id']
                origin_device_name = provider_volume.extra['device']
                self.adpter.detach_volume(provider_volume)
                time.sleep(1)
                retry_time = 50
                provider_volume = self._get_provider_volume(provider_volume_id)
                while retry_time > 0:
                    if provider_volume and provider_volume.extra.get(
                            'attachment_status') is None:
                        break
                    else:
                        time.sleep(1)
                        provider_volume = self._get_provider_volume(
                            provider_volume_id)
                        retry_time = retry_time - 1
            #3.attach the volume to vgw host
            try:
                #3.1 get the vgw host
                vgw_host = self._get_provider_node(
                    self.configuration.cgw_host_id)
                if not vgw_host:
                    raise exception_ex.VgwHostNotFound(
                        Vgw_id=self.configuration.cgw_host_id)
                device_name = self._get_next_device_name(vgw_host)
                LOG.error('**********************************************')
                LOG.error('the volume status %s' % provider_volume.state)
                self.adpter.attach_volume(vgw_host, provider_volume,
                                          device_name)
                #query volume status
                time.sleep(1)
                retry_time = 120
                provider_volume = self._get_provider_volume(provider_volume_id)
                while retry_time > 0:
                    if provider_volume and provider_volume.extra.get(
                            'attachment_status') == 'attached':
                        break
                    else:
                        time.sleep(1)
                        provider_volume = self._get_provider_volume(
                            provider_volume_id)
                        retry_time = retry_time - 1

            except Exception as e:
                raise e
            time.sleep(5)
            conn = rpyc.connect(self.configuration.cgw_host_ip,
                                int(CONF.vgw.rpc_service_port))
            LOG.error('begin time of copy_volume_to_file is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            full_file_path = conn.root.copy_volume_to_file(
                device_name, file_name, CONF.vgw.store_file_dir)
            LOG.error('end time of copy_volume_to_image is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            #todo exception occured clean env
            if not full_file_path:
                self.adpter.detach_volume(provider_volume)
                conn.close()
                raise exception_ex.ProviderExportVolumeError(
                    volume_id=volume_id)
            LOG.error('begin time of push_file_to_vgw is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            push_file_result = conn.root.exposed_push_file_to_vgw(
                full_file_path, vgw_url)
            LOG.error('end time of push_file_to_vgw is %s' %
                      (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
            if not push_file_result:
                LOG.error('post file file %s  to %s failed' %
                          (push_file_result, vgw_url))
                self.adpter.detach_volume(provider_volume)
                conn.close()
                raise exception_ex.ProviderExportVolumeError(
                    volume_id=volume_id)
            conn.close()
            #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)
            #4.detach form vgw
            self.adpter.detach_volume(provider_volume)
            time.sleep(1)
            retry_time = 120
            provider_volume = self._get_provider_volume(provider_volume_id)
            while retry_time > 0:
                if provider_volume and provider_volume.extra.get(
                        'attachment_status') is None:
                    break
                else:
                    time.sleep(1)
                    provider_volume = self._get_provider_volume(
                        provider_volume_id)
                    retry_time = retry_time - 1
            LOG.error('**********************************************')
            LOG.error('the volume status %s' % provider_volume.state)
            #attach the volume back
            if origin_provider_volume_state is not None:
                origin_attach_node = self._get_provider_node(
                    origin_attach_node_id)

                self.adpter.attach_volume(origin_attach_node, provider_volume,
                                          origin_device_name)

        else:
            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)
        LOG.error('end time of copy_volume_to_image is %s' %
                  (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
示例#33
0
    def copy_volume_to_image(self, context, volume, image_service, image_meta):
        """Copy the volume to the specified image.

        copy disk to image and disk for image.
        """
        # TODO(haifeng)user delete iamge on openstack, image still in Azure.
        azure_type = StorageAccountTypes.premium_lrs \
            if 'azure_ssd' == volume.volume_type.name \
            else StorageAccountTypes.standard_lrs
        metadata = volume.get('volume_metadata', [])
        metadata_dict = {item['key']: item['value'] for item in metadata}
        os_type = metadata_dict.get('os_type')
        if not os_type:
            reason = 'Volume miss os_type can\'t copy to Image.'
            message = (_("Copy Volume to Image %(image_id)s in Azure"
                         " failed. reason: %(reason)s") %
                       dict(image_id=image_meta['id'], reason=reason))
            LOG.exception(message)
            raise exception.VolumeBackendAPIException(data=message)

        disk_name = self._get_name_from_id(VOLUME_PREFIX, volume['id'])
        image_name = self._get_name_from_id(IMAGE_PREFIX, image_meta['id'])
        try:
            disk_obj = self.disks.get(CONF.azure.resource_group, disk_name)
        except Exception as e:
            message = (_("Create Image from Volume %(volume)s in Azure"
                         " failed. reason: %(reason)s") %
                       dict(volume=volume['id'], reason=six.text_type(e)))
            LOG.exception(message)
            raise exception.VolumeBackendAPIException(data=message)
        self._copy_disk(image_name, disk_obj.id, azure_type)
        try:
            image_dict = {
                'location': CONF.azure.location,
                'storage_profile': {
                    'os_disk': {
                        'os_type': os_type,
                        'os_state': "Generalized",
                        'managed_disk': {
                            'id': disk_obj.id
                        }
                    }
                }
            }
            async_action = self.images.create_or_update(
                CONF.azure.resource_group, image_name, image_dict)
            async_action.result()
        except Exception as e:
            message = (_("Copy Volume to Image %(volume)s in Azure"
                         " failed. reason: %(reason)s") %
                       dict(volume=disk_name, reason=six.text_type(e)))
            LOG.exception(message)
            raise exception.VolumeBackendAPIException(data=message)

        # create a empty file to glance
        with image_utils.temporary_file() as tmp:
            image_utils.upload_volume(context, image_service, image_meta, tmp)

        image_meta['disk_format'] = 'vhd'
        image_meta['properties'] = {
            'os_type': os_type,
            'azure_image_size_gb': volume.size
        }
        image_service.update(context, image_meta['id'], image_meta)