def _make_disks(self):
for drive in self.boot_caps.drives:
path = self._abspath(drive.disk.file)
size = None
if drive.disk.size is not None:
size = float(drive.disk.size) / 1024
# FIXME: This is awkward; the image should be able to express
# whether the disk is expected to be there or not independently
# of its classification, especially for user disks
# FIXME: We ignore the target for the mapping in m.target
if (drive.disk.use == ImageParser.Disk.USE_SYSTEM and
not os.path.exists(path)):
raise ImageInstallerException(_("System disk %s does not exist")
% path)
device = VirtualDisk.DEVICE_DISK
if drive.disk.format == ImageParser.Disk.FORMAT_ISO:
device = VirtualDisk.DEVICE_CDROM
disk = VirtualDisk(conn=self.conn,
path=path,
size=size,
device=device,
format=drive.disk.format)
disk.target = drive.target
self.install_devices.append(disk)
def _make_disks(self):
for drive in self.boot_caps.drives:
path = self._abspath(drive.disk.file)
size = None
if drive.disk.size is not None:
size = float(drive.disk.size) / 1024
# FIXME: This is awkward; the image should be able to express
# whether the disk is expected to be there or not independently
# of its classification, especially for user disks
# FIXME: We ignore the target for the mapping in m.target
if (drive.disk.use == ImageParser.Disk.USE_SYSTEM
and not os.path.exists(path)):
raise ImageInstallerException(
_("System disk %s does not exist") % path)
device = VirtualDisk.DEVICE_DISK
if drive.disk.format == ImageParser.Disk.FORMAT_ISO:
device = VirtualDisk.DEVICE_CDROM
disk = VirtualDisk(conn=self.conn,
path=path,
size=size,
device=device,
format=drive.disk.format)
disk.target = drive.target
self.install_devices.append(disk)
def _prepare_kernel_and_initrd(self, guest, meter):
disk = None
# If installing off a local path, map it through to a virtual CD/disk
if (self.location is not None and self._location_is_path
and not os.path.isdir(self.location)):
device = VirtualDisk.DEVICE_CDROM
# pylint: disable=W0212
# Access to protected member lookup_osdict_key
can_cdrom = guest._lookup_osdict_key('pv_cdrom_install')
# pylint: enable=W0212
if self.is_xenpv() and can_cdrom:
device = VirtualDisk.DEVICE_DISK
disk = VirtualDisk(conn=guest.conn,
device=device,
path=self.location,
readOnly=True,
transient=True)
# Make sure we always fetch kernel here if required
if self._install_bootconfig.kernel and not self.scratchdir_required():
return disk
# Need to fetch the kernel & initrd from a remote site, or
# out of a loopback mounted disk image/device
ignore, os_type, os_variant, media = OSDistro.getKernel(
guest, self.location, meter, self.scratchdir, self.os_type)
(kernelfn, initrdfn, args) = media
if guest.get_os_autodetect():
if os_type:
logging.debug("Auto detected OS type as: %s", os_type)
guest.os_type = os_type
if (os_variant and guest.os_type == os_type):
logging.debug("Auto detected OS variant as: %s", os_variant)
guest.os_variant = os_variant
self._tmpfiles.append(kernelfn)
if initrdfn:
self._tmpfiles.append(initrdfn)
if self._initrd_injections:
self._perform_initrd_injections(initrdfn)
# If required, upload media to an accessible guest location
kernelfn, initrdfn = self._upload_media(guest, meter, kernelfn,
initrdfn)
self._install_bootconfig.kernel = kernelfn
self._install_bootconfig.initrd = initrdfn
self._install_bootconfig.kernel_args = args
return disk
def _validate_location(self, val):
path = None
vol_tuple = None
if type(val) is tuple:
vol_tuple = val
else:
path = val
disk = None
if path or vol_tuple:
disk = VirtualDisk(path=path,
conn=self.conn,
volName=vol_tuple,
device=VirtualDisk.DEVICE_CDROM,
readOnly=True)
return disk
def _prepare_cdrom(self, guest, meter):
transient = not self.livecd
if not self._location_is_path:
# Xen needs a boot.iso if its a http://, ftp://, or nfs: url
(store_ignore, os_type_ignore, os_variant_ignore,
media) = OSDistro.getBootDisk(guest, self.location, meter,
self.scratchdir)
cdrom = media
self._tmpfiles.append(cdrom)
transient = True
else:
cdrom = self.location
disk = VirtualDisk(path=cdrom,
conn=guest.conn,
device=VirtualDisk.DEVICE_CDROM,
readOnly=True,
transient=transient)
self.install_devices.append(disk)
def _upload_file(conn, meter, destpool, src):
# Build stream object
stream = conn.newStream(0)
def safe_send(data):
while True:
ret = stream.send(data)
if ret == 0 or ret == len(data):
break
data = data[ret:]
if meter is None:
meter = urlgrabber.progress.BaseMeter()
# Build placeholder volume
size = os.path.getsize(src)
basename = os.path.basename(src)
poolpath = util.get_xml_path(destpool.XMLDesc(0), "/pool/target/path")
name = Storage.StorageVolume.find_free_name(basename, pool_object=destpool)
if name != basename:
logging.debug("Generated non-colliding volume name %s", name)
disk = VirtualDisk(conn=conn,
path=os.path.join(poolpath, name),
sizebytes=size,
sparse=True)
disk.setup_dev(meter=meter)
vol = disk.vol_object
if not vol:
raise RuntimeError(_("Failed to lookup scratch media volume"))
try:
# Register upload
offset = 0
length = size
flags = 0
stream.upload(vol, offset, length, flags)
# Open source file
fileobj = file(src, "r")
# Start transfer
total = 0
meter.start(size=size,
text=_("Transferring %s") % os.path.basename(src))
while True:
# blocksize = (1024 ** 2)
blocksize = 1024
data = fileobj.read(blocksize)
if not data:
break
safe_send(data)
total += len(data)
meter.update(total)
# Cleanup
stream.finish()
meter.end(size)
except:
if vol:
vol.delete(0)
raise
return vol
def set_location(self, val):
"""
Valid values for location:
1) it can be a local file (ex. boot.iso), directory (ex. distro
tree) or physical device (ex. cdrom media)
2) tuple of the form (poolname, volname) pointing to a file or
device which will set location as that path
3) http, ftp, or nfs path for an install tree
"""
is_tuple = False
validated = True
self._location_is_path = True
is_local = (not self.conn or not self.is_remote())
# Basic validation
if type(val) is not str and (type(val) is not tuple and len(val) != 2):
raise ValueError(_("Invalid 'location' type %s." % type(val)))
if type(val) is tuple and len(val) == 2:
logging.debug("DistroInstaller location is a (poolname, volname)"
" tuple")
if not self.conn:
raise ValueError(
_("'conn' must be specified if 'location' is"
" a storage tuple."))
is_tuple = True
elif _is_url(val, is_local):
val = _sanitize_url(val)
self._location_is_path = False
logging.debug("DistroInstaller location is a network source.")
elif os.path.exists(os.path.abspath(val)) and is_local:
val = os.path.abspath(val)
logging.debug(
"DistroInstaller location is a local "
"file/path: %s", val)
else:
# Didn't determine anything about the location
validated = False
if self._location_is_path or (not validated and self.conn
and util.is_storage_capable(self.conn)):
# If user passed a storage tuple, OR
# We couldn't determine the location type and a storage capable
# connection was passed:
# Pass the parameters off to VirtualDisk to validate, and pull
# out the path
stuple = (is_tuple and val) or None
path = (not is_tuple and val) or None
try:
d = VirtualDisk(path=path,
device=VirtualDisk.DEVICE_CDROM,
transient=True,
readOnly=True,
conn=self.conn,
volName=stuple)
val = d.path
except:
logging.debug("Error validating install location",
exc_info=True)
raise ValueError(
_("Checking installer location failed: "
"Could not find media '%s'." % str(val)))
elif not validated:
raise ValueError(
_("Install media location must be an NFS, HTTP "
"or FTP network install source, or an existing "
"file/device"))
if (not self._location_is_path and val.startswith("nfs:") and
not User.current().has_priv(User.PRIV_NFS_MOUNT,
(self.conn and self.get_uri()))):
raise ValueError(_('Privilege is required for NFS installations'))
self._location = val
def _upload_file(conn, meter, destpool, src):
# Build stream object
stream = conn.newStream(0)
def safe_send(data):
while True:
ret = stream.send(data)
if ret == 0 or ret == len(data):
break
data = data[ret:]
if meter is None:
meter = urlgrabber.progress.BaseMeter()
# Build placeholder volume
size = os.path.getsize(src)
basename = os.path.basename(src)
poolpath = util.get_xml_path(destpool.XMLDesc(0), "/pool/target/path")
name = Storage.StorageVolume.find_free_name(basename, pool_object=destpool)
if name != basename:
logging.debug("Generated non-colliding volume name %s", name)
disk = VirtualDisk(conn=conn, path=os.path.join(poolpath, name), sizebytes=size, sparse=True)
disk.setup_dev(meter=meter)
vol = disk.vol_object
if not vol:
raise RuntimeError(_("Failed to lookup scratch media volume"))
try:
# Register upload
offset = 0
length = size
flags = 0
stream.upload(vol, offset, length, flags)
# Open source file
fileobj = file(src, "r")
# Start transfer
total = 0
meter.start(size=size, text=_("Transferring %s") % os.path.basename(src))
while True:
# blocksize = (1024 ** 2)
blocksize = 1024
data = fileobj.read(blocksize)
if not data:
break
safe_send(data)
total += len(data)
meter.update(total)
# Cleanup
stream.finish()
meter.end(size)
except:
if vol:
vol.delete(0)
raise
return vol
