def download_flat_image(context, timeout_secs, image_service, image_id, **kwargs): """Download flat image from the image service to VMware server. :param context: image service write context :param timeout_secs: time in seconds to wait for the download to complete :param image_service: image service handle :param image_id: ID of the image to be downloaded :param kwargs: keyword arguments to configure the destination file write handle :raises: VimConnectionException, ImageTransferException, ValueError """ LOG.debug("Downloading image: %s from image service as a flat file.", image_id) # TODO(vbala) catch specific exceptions raised by download call read_iter = image_service.download(context, image_id) read_handle = rw_handles.ImageReadHandle(read_iter) file_size = int(kwargs.get('image_size')) write_handle = rw_handles.FileWriteHandle(kwargs.get('host'), kwargs.get('port'), kwargs.get('data_center_name'), kwargs.get('datastore_name'), kwargs.get('cookies'), kwargs.get('file_path'), file_size, cacerts=kwargs.get('cacerts')) _start_transfer(read_handle, write_handle, timeout_secs) LOG.debug("Downloaded image: %s from image service as a flat file.", image_id)
def download_image(image, image_meta, session, datastore, rel_path, bypass=True, timeout_secs=7200): """Transfer an image to a datastore. :param image: file-like iterator :param image_meta: image metadata :param session: VMwareAPISession object :param datastore: Datastore object :param rel_path: path where the file will be stored in the datastore :param bypass: if set to True, bypass vCenter to download the image :param timeout_secs: time in seconds to wait for the xfer to complete """ image_size = int(image_meta['size']) method = 'PUT' if bypass: hosts = datastore.get_connected_hosts(session) host = ds_obj.Datastore.choose_host(hosts) host_name = session.invoke_api(vim_util, 'get_object_property', session.vim, host, 'name') ds_url = datastore.build_url(session._scheme, host_name, rel_path, constants.ESX_DATACENTER_PATH) cookie = ds_url.get_transfer_ticket(session, method) conn = ds_url.connect(method, image_size, cookie) else: ds_url = datastore.build_url(session._scheme, session._host, rel_path) cookie = '%s=%s' % (constants.SOAP_COOKIE_KEY, session.vim.get_http_cookie().strip("\"")) conn = ds_url.connect(method, image_size, cookie) conn.write = conn.send read_handle = rw_handles.ImageReadHandle(image) _start_transfer(read_handle, conn, timeout_secs)
def download_stream_optimized_image(context, timeout_secs, image_service, image_id, **kwargs): """Download stream optimized image from image service to VMware server. :param context: image service write context :param timeout_secs: time in seconds to wait for the download to complete :param image_service: image service handle :param image_id: ID of the image to be downloaded :param kwargs: keyword arguments to configure the destination VMDK write handle :returns: managed object reference of the VM created for import to VMware server :raises: VimException, VimFaultException, VimAttributeException, VimSessionOverLoadException, VimConnectionException, ImageTransferException, ValueError """ LOG.debug("Downloading image: %s from image service as a stream " "optimized file.", image_id) # TODO(vbala) catch specific exceptions raised by download call read_iter = image_service.download(context, image_id) read_handle = rw_handles.ImageReadHandle(read_iter) imported_vm = download_stream_optimized_data(context, timeout_secs, read_handle, **kwargs) LOG.debug("Downloaded image: %s from image service as a stream " "optimized file.", image_id) return imported_vm
def fetch_image(context, instance, host, port, dc_name, ds_name, file_path, cookies=None): """Download image from the glance image server.""" image_ref = instance.image_ref LOG.debug( "Downloading image file data %(image_ref)s to the " "data store %(data_store_name)s", { 'image_ref': image_ref, 'data_store_name': ds_name }, instance=instance) metadata = IMAGE_API.get(context, image_ref) file_size = int(metadata['size']) read_iter = IMAGE_API.download(context, image_ref) read_file_handle = rw_handles.ImageReadHandle(read_iter) write_file_handle = rw_handles.FileWriteHandle(host, port, dc_name, ds_name, cookies, file_path, file_size) image_transfer(read_file_handle, write_file_handle) LOG.debug( "Downloaded image file data %(image_ref)s to " "%(upload_name)s on the data store " "%(data_store_name)s", { 'image_ref': image_ref, 'upload_name': 'n/a' if file_path is None else file_path, 'data_store_name': 'n/a' if ds_name is None else ds_name }, instance=instance)
def fetch_image_stream_optimized(context, instance, session, vm_name, ds_name, vm_folder_ref, res_pool_ref): """Fetch image from Glance to ESX datastore.""" image_ref = instance.image_ref LOG.debug("Downloading image file data %(image_ref)s to the ESX " "as VM named '%(vm_name)s'", {'image_ref': image_ref, 'vm_name': vm_name}, instance=instance) metadata = IMAGE_API.get(context, image_ref) file_size = int(metadata['size']) vm_import_spec = _build_import_spec_for_import_vapp( session, vm_name, ds_name) read_iter = IMAGE_API.download(context, image_ref) read_handle = rw_handles.ImageReadHandle(read_iter) write_handle = rw_handles.VmdkWriteHandle(session, session._host, session._port, res_pool_ref, vm_folder_ref, vm_import_spec, file_size) image_transfer(read_handle, write_handle) imported_vm_ref = write_handle.get_imported_vm() LOG.info("Downloaded image file data %(image_ref)s", {'image_ref': instance.image_ref}, instance=instance) vmdk = vm_util.get_vmdk_info(session, imported_vm_ref, vm_name) session._call_method(session.vim, "UnregisterVM", imported_vm_ref) LOG.info("The imported VM was unregistered", instance=instance) return vmdk.capacity_in_bytes
def fetch_image_ova(context, instance, session, vm_name, ds_name, vm_folder_ref, res_pool_ref): """Download the OVA image from the glance image server to the Nova compute node. """ image_ref = instance.image_ref LOG.debug( "Downloading OVA image file %(image_ref)s to the ESX " "as VM named '%(vm_name)s'", { 'image_ref': image_ref, 'vm_name': vm_name }, instance=instance) metadata = IMAGE_API.get(context, image_ref) file_size = int(metadata['size']) vm_import_spec = _build_import_spec_for_import_vapp( session, vm_name, ds_name) read_iter = IMAGE_API.download(context, image_ref) read_handle = rw_handles.ImageReadHandle(read_iter) with tarfile.open(mode="r|", fileobj=read_handle) as tar: vmdk_name = None for tar_info in tar: if tar_info and tar_info.name.endswith(".ovf"): extracted = tar.extractfile(tar_info) xmlstr = extracted.read() vmdk_name = get_vmdk_name_from_ovf(xmlstr) elif vmdk_name and tar_info.name.startswith(vmdk_name): # Actual file name is <vmdk_name>.XXXXXXX extracted = tar.extractfile(tar_info) write_handle = rw_handles.VmdkWriteHandle( session, session._host, session._port, res_pool_ref, vm_folder_ref, vm_import_spec, file_size) start_transfer(context, extracted, file_size, write_file_handle=write_handle) extracted.close() LOG.info(_LI("Downloaded OVA image file %(image_ref)s"), {'image_ref': instance.image_ref}, instance=instance) imported_vm_ref = write_handle.get_imported_vm() vmdk = vm_util.get_vmdk_info(session, imported_vm_ref, vm_name) session._call_method(session.vim, "UnregisterVM", imported_vm_ref) LOG.info(_LI("The imported VM was unregistered"), instance=instance) return vmdk.capacity_in_bytes raise exception.ImageUnacceptable( reason=_("Extracting vmdk from OVA failed."), image_id=image_ref)
def create_read_connection(read_iter, ova_file, is_url): """ Creates a read connection for the OVA base image """ if is_url: read_connection = rw_handles.ImageReadHandle(read_iter) else: # this has to be a fresh read, since tarfile needs a file # object starting from 0. Hence not using read_iter in the # case of local file. read_connection = open(ova_file) return read_connection
def download_stream_optimized_image(context, timeout_secs, image_service, image_id, **kwargs): """Download stream optimized image from image service to VMware server. :param context: image service write context :param timeout_secs: time in seconds to wait for the download to complete :param image_service: image service handle :param image_id: ID of the image to be downloaded :param kwargs: keyword arguments to configure the destination VMDK write handle :returns: managed object reference of the VM created for import to VMware server :raises: VimException, VimFaultException, VimAttributeException, VimSessionOverLoadException, VimConnectionException, ImageTransferException, ValueError """ metadata = image_service.show(context, image_id) container_format = metadata.get('container_format') LOG.debug( "Downloading image: %(id)s (container: %(container)s) from image" " service as a stream optimized file.", { 'id': image_id, 'container': container_format }) # TODO(vbala) catch specific exceptions raised by download call read_iter = image_service.download(context, image_id) read_handle = rw_handles.ImageReadHandle(read_iter) if container_format == 'ova': read_handle = _get_vmdk_handle(read_handle) if read_handle is None: raise exceptions.ImageTransferException( _("No vmdk found in the OVA image %s.") % image_id) imported_vm = download_stream_optimized_data(context, timeout_secs, read_handle, **kwargs) LOG.debug( "Downloaded image: %s from image service as a stream " "optimized file.", image_id) return imported_vm
def test_read(self): max_items = 10 item = [1] * 10 class ImageReadIterator(six.Iterator): def __init__(self): self.num_items = 0 def __iter__(self): return self def __next__(self): if (self.num_items < max_items): self.num_items += 1 return item raise StopIteration next = __next__ handle = rw_handles.ImageReadHandle(ImageReadIterator()) for _ in range(0, max_items): self.assertEqual(item, handle.read(10)) self.assertFalse(handle.read(10))