def _do_mount(self):
"""Run CD-ROM installation source setup."""
log.debug("Trying to detect CD-ROM automatically")
device_tree = STORAGE.get_proxy(DEVICE_TREE)
device_name = ""
for dev_name in device_tree.FindOpticalMedia():
try:
device_data = DeviceData.from_structure(
device_tree.GetDeviceData(dev_name))
mount(device_data.path, self._target_mount, "iso9660", "ro")
except PayloadSetupError:
continue
if is_valid_install_disk(self._target_mount):
device_name = dev_name
log.info("using CD-ROM device %s mounted at %s", dev_name,
self._target_mount)
break
else:
unmount(self._target_mount)
if not device_name:
raise SourceSetupError("Found no CD-ROM")
def _mount_image(self, image_path, mount_point):
# Work around inability to move shared filesystems.
# Also, do not share the image mounts with /run bind-mounted to physical
# target root during storage.mount_filesystems.
rc = execWithRedirect("mount", ["--make-rprivate", "/"])
if rc != 0:
log.error("mount error (%s) making mount of '/' rprivate", rc)
raise SourceSetupError("Mount error {}".format(rc))
# Mount the image and check to see if it is a LiveOS/*.img
# style squashfs image. If so, move it to IMAGE_DIR and mount the real
# root image on mount_point
rc = mount(image_path, mount_point, fstype="auto", options="ro")
if rc != 0:
log.error("mount error (%s) with %s", rc, image_path)
raise SourceSetupError("Mount error {}".format(rc))
nested_image_files = glob.glob(mount_point + "/LiveOS/*.img")
if nested_image_files:
# Mount the first .img in the directory on mount_point
nested_image = sorted(nested_image_files)[0]
# move the mount to IMAGE_DIR
os.makedirs(IMAGE_DIR, 0o755)
rc = execWithRedirect("mount", ["--move", mount_point, IMAGE_DIR])
if rc != 0:
log.error("error %s moving mount", rc)
raise SourceSetupError("Mount error {}".format(rc))
nested_image_path = IMAGE_DIR + "/LiveOS/" + os.path.basename(nested_image)
rc = mount(nested_image_path, mount_point, fstype="auto", options="ro")
if rc != 0:
log.error("mount error (%s) with %s", rc, nested_image_path)
raise SourceSetupError("Mount error {} with {}".format(rc, nested_image_path))
def _mount_nfs(self, host, options, path):
if not options:
options = "nolock"
elif "nolock" not in options:
options += ",nolock"
mount("{}:{}".format(host, path), self._device_mount, fstype="nfs", options=options)
def _setup_NFS(mountpoint, server, path, options):
"""Prepare an NFS directory for use as an install source."""
log.info("mounting %s:%s:%s on %s", server, path, options, mountpoint)
device_path = payload_utils.get_mount_device_path(mountpoint)
# test if the mountpoint is occupied already
if device_path:
_server, colon, _path = device_path.partition(":")
if colon == ":" and server == _server and path == _path:
log.debug("%s:%s already mounted on %s", server, path,
mountpoint)
return
else:
log.debug("%s already has something mounted on it", mountpoint)
payload_utils.unmount(mountpoint)
# mount the specified directory
url = "%s:%s" % (server, path)
if not options:
options = "nolock"
elif "nolock" not in options:
options += ",nolock"
payload_utils.mount(url, mountpoint, fstype="nfs", options=options)
def _mount_nfs(self):
options, host, path = parse_nfs_url(self._url)
if not options:
options = "nolock"
elif "nolock" not in options:
options += ",nolock"
mount("{}:{}".format(host, path),
self._device_mount,
fstype="nfs",
options=options)
def setup(self):
super().setup()
# Mount the live device and copy from it instead of the overlay at /
osimg = payload_utils.resolve_device(self.data.method.partition)
if not osimg:
raise PayloadInstallError("Unable to find osimg for %s" %
self.data.method.partition)
osimg_path = payload_utils.get_device_path(osimg)
if not stat.S_ISBLK(os.stat(osimg_path)[stat.ST_MODE]):
exn = PayloadSetupError("%s is not a valid block device" %
(self.data.method.partition, ))
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
rc = payload_utils.mount(osimg_path,
INSTALL_TREE,
fstype="auto",
options="ro")
if rc != 0:
raise PayloadInstallError("Failed to mount the install tree")
# Grab the kernel version list now so it's available after umount
self._update_kernel_version_list()
source = os.statvfs(INSTALL_TREE)
self.source_size = source.f_frsize * (source.f_blocks - source.f_bfree)
def setup(self):
super().setup()
# Mount the live device and copy from it instead of the overlay at /
osimg_spec = self._get_live_os_image()
if not osimg_spec:
raise PayloadSetupError("No live image found!")
osimg = payload_utils.resolve_device(osimg_spec)
if not osimg:
raise PayloadSetupError(
"Unable to find osimg for {}".format(osimg_spec))
osimg_path = payload_utils.get_device_path(osimg)
if not stat.S_ISBLK(os.stat(osimg_path)[stat.ST_MODE]):
raise PayloadSetupError(
"{} is not a valid block device".format(osimg_spec))
rc = payload_utils.mount(osimg_path,
INSTALL_TREE,
fstype="auto",
options="ro")
if rc != 0:
raise PayloadSetupError("Failed to mount the install tree")
# Grab the kernel version list now so it's available after umount
self._update_kernel_version_list()
def _do_mount(self):
"""Set up the installation source."""
log.debug("Trying to mount NFS: %s", self._url)
options, host, path = parse_nfs_url(self._url)
if not options:
options = "nolock"
elif "nolock" not in options:
options += ",nolock"
mount("{}:{}".format(host, path),
self._target_mount,
fstype="nfs",
options=options)
log.debug("We are ready to use NFS at %s.", self._target_mount)
def _find_and_mount_iso(self, device, device_mount_dir, iso_path,
iso_mount_dir):
"""Find and mount installation source from ISO on device.
Return changed path to the iso to save looking for iso in the future call.
"""
self._setup_device(device, mountpoint=device_mount_dir)
# check for ISO images in the newly mounted dir
path = device_mount_dir
if iso_path:
path = os.path.normpath("%s/%s" % (path, iso_path))
# XXX it would be nice to streamline this when we're just setting
# things back up after storage activation instead of having to
# pretend we don't already know which ISO image we're going to
# use
image = find_first_iso_image(path)
if not image:
payload_utils.teardown_device(device)
raise PayloadSetupError("failed to find valid iso image")
if path.endswith(".iso"):
path = os.path.dirname(path)
# this could already be set up the first time through
if not os.path.ismount(iso_mount_dir):
# mount the ISO on a loop
image = os.path.normpath("%s/%s" % (path, image))
payload_utils.mount(image,
iso_mount_dir,
fstype='iso9660',
options="ro")
if not iso_path.endswith(".iso"):
result_path = os.path.normpath("%s/%s" %
(iso_path, os.path.basename(image)))
while result_path.startswith("/"):
# ridiculous
result_path = result_path[1:]
return result_path
return iso_path
def _choose_installation_device(self, device_tree, devices_candidates):
device_name = ""
for dev_name in devices_candidates:
try:
device_data = DeviceData.from_structure(
device_tree.GetDeviceData(dev_name))
mount(device_data.path, self._target_mount, "iso9660", "ro")
except OSError as e:
log.debug("Failed to mount %s: %s", dev_name, str(e))
continue
if is_valid_install_disk(self._target_mount):
device_name = dev_name
log.info("using CD-ROM device %s mounted at %s", dev_name,
self._target_mount)
break
else:
unmount(self._target_mount)
return device_name
def run(self):
"""Set up the installation source."""
log.debug("Trying to mount NFS: %s", self._url)
if ismount(self._target_mount):
raise SourceSetupError(
"Something is already mounted at the target {}".format(
self._target_mount))
options, host, path = parse_nfs_url(self._url)
if not options:
options = "nolock"
elif "nolock" not in options:
options += ",nolock"
mount("{}:{}".format(host, path),
self._target_mount,
fstype="nfs",
options=options)
log.debug("We are ready to use NFS at %s.", self._target_mount)
def _setup_NFS(mountpoint, server, path, options):
"""Prepare an NFS directory for use as an install source."""
log.info("mounting %s:%s:%s on %s", server, path, options, mountpoint)
dev = payload_utils.get_mount_device(mountpoint)
# test if the mountpoint is occupied already
if dev:
_server, colon, _path = dev.partition(":")
if colon == ":" and server == _server and path == _path:
log.debug("%s:%s already mounted on %s", server, path, mountpoint)
return
else:
log.debug("%s already has something mounted on it", mountpoint)
payload_utils.unmount(mountpoint)
# mount the specified directory
url = "%s:%s" % (server, path)
if not options:
options = "nolock"
elif "nolock" not in options:
options += ",nolock"
payload_utils.mount(url, mountpoint, fstype="nfs", options=options)
def run(self):
"""Run live installation source setup."""
# Mount the live device and copy from it instead of the overlay at /
device_tree = STORAGE.get_proxy(DEVICE_TREE)
device_name = device_tree.ResolveDevice(self._live_partition)
if not device_name:
raise SourceSetupError("Failed to find liveOS image!")
device_data = DeviceData.from_structure(device_tree.GetDeviceData(device_name))
if not stat.S_ISBLK(os.stat(device_data.path)[stat.ST_MODE]):
raise SourceSetupError("{} is not a valid block device".format(
self._live_partition))
rc = mount(device_data.path, self._target_mount, fstype="auto", options="ro")
if rc != 0:
raise SourceSetupError("Failed to mount the install tree")
def pre_install(self):
""" Get image and loopback mount it.
This is called after partitioning is setup, we now have space to
grab the image. If it is a network source Download it to sysroot
and provide feedback during the download (using urlgrabber
callback).
If it is a file:// source then use the file directly.
"""
error = None
if self.data.liveimg.url.startswith("file://"):
self.image_path = self.data.liveimg.url[7:]
else:
error = self._pre_install_url_image()
if error:
raise PayloadInstallError(str(error))
# Verify the checksum.
task = VerifyImageChecksum(image_path=self.image_path,
checksum=self.data.liveimg.checksum)
task.progress_changed_signal.connect(self._progress_cb)
task.run()
# If this looks like a tarfile, skip trying to mount it
if self.is_tarfile:
return
# Work around inability to move shared filesystems.
# Also, do not share the image mounts with /run bind-mounted to physical
# target root during storage.mount_filesystems.
rc = util.execWithRedirect("mount", ["--make-rprivate", "/"])
if rc != 0:
log.error("mount error (%s) making mount of '/' rprivate", rc)
raise PayloadInstallError("mount error %s" % rc)
# Mount the image and check to see if it is a LiveOS/*.img
# style squashfs image. If so, move it to IMAGE_DIR and mount the real
# root image on INSTALL_TREE
rc = payload_utils.mount(self.image_path,
INSTALL_TREE,
fstype="auto",
options="ro")
if rc != 0:
log.error("mount error (%s) with %s", rc, self.image_path)
raise PayloadInstallError("mount error %s" % rc)
# Nothing more to mount
if not os.path.exists(INSTALL_TREE + "/LiveOS"):
self._update_kernel_version_list()
return
# Mount the first .img in the directory on INSTALL_TREE
img_files = glob.glob(INSTALL_TREE + "/LiveOS/*.img")
if img_files:
# move the mount to IMAGE_DIR
os.makedirs(IMAGE_DIR, 0o755)
rc = util.execWithRedirect("mount",
["--move", INSTALL_TREE, IMAGE_DIR])
if rc != 0:
log.error("error %s moving mount", rc)
raise PayloadInstallError("mount error %s" % rc)
img_file = IMAGE_DIR + "/LiveOS/" + os.path.basename(
sorted(img_files)[0])
rc = payload_utils.mount(img_file,
INSTALL_TREE,
fstype="auto",
options="ro")
if rc != 0:
log.error("mount error (%s) with %s", rc, img_file)
raise PayloadInstallError("mount error %s with %s" %
(rc, img_file))
self._update_kernel_version_list()
def pre_install(self):
""" Get image and loopback mount it.
This is called after partitioning is setup, we now have space to
grab the image. If it is a network source Download it to sysroot
and provide feedback during the download (using urlgrabber
callback).
If it is a file:// source then use the file directly.
"""
error = None
if self.data.method.url.startswith("file://"):
self.image_path = self.data.method.url[7:]
else:
error = self._pre_install_url_image()
if error:
exn = PayloadInstallError(str(error))
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# Used to make install progress % look correct
self._adj_size = os.stat(self.image_path)[stat.ST_SIZE]
if self.data.method.checksum:
progressQ.send_message(_("Checking image checksum"))
sha256 = hashlib.sha256()
with open(self.image_path, "rb") as f:
while True:
data = f.read(1024 * 1024)
if not data:
break
sha256.update(data)
filesum = sha256.hexdigest()
log.debug("sha256 of %s is %s", self.data.method.url, filesum)
if util.lowerASCII(self.data.method.checksum) != filesum:
log.error("%s does not match checksum.",
self.data.method.checksum)
exn = PayloadInstallError("Checksum of image does not match")
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# If this looks like a tarfile, skip trying to mount it
if self.is_tarfile:
return
# Work around inability to move shared filesystems.
# Also, do not share the image mounts with /run bind-mounted to physical
# target root during storage.mount_filesystems.
rc = util.execWithRedirect("mount", ["--make-rprivate", "/"])
if rc != 0:
log.error("mount error (%s) making mount of '/' rprivate", rc)
exn = PayloadInstallError("mount error %s" % rc)
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# Mount the image and check to see if it is a LiveOS/*.img
# style squashfs image. If so, move it to IMAGE_DIR and mount the real
# root image on INSTALL_TREE
rc = payload_utils.mount(self.image_path,
INSTALL_TREE,
fstype="auto",
options="ro")
if rc != 0:
log.error("mount error (%s) with %s", rc, self.image_path)
exn = PayloadInstallError("mount error %s" % rc)
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
# Nothing more to mount
if not os.path.exists(INSTALL_TREE + "/LiveOS"):
self._update_kernel_version_list()
return
# Mount the first .img in the directory on INSTALL_TREE
img_files = glob.glob(INSTALL_TREE + "/LiveOS/*.img")
if img_files:
# move the mount to IMAGE_DIR
os.makedirs(IMAGE_DIR, 0o755)
rc = util.execWithRedirect("mount",
["--move", INSTALL_TREE, IMAGE_DIR])
if rc != 0:
log.error("error %s moving mount", rc)
exn = PayloadInstallError("mount error %s" % rc)
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
img_file = IMAGE_DIR + "/LiveOS/" + os.path.basename(
sorted(img_files)[0])
rc = payload_utils.mount(img_file,
INSTALL_TREE,
fstype="auto",
options="ro")
if rc != 0:
log.error("mount error (%s) with %s", rc, img_file)
exn = PayloadInstallError("mount error %s with %s" %
(rc, img_file))
if errorHandler.cb(exn) == ERROR_RAISE:
raise exn
self._update_kernel_version_list()
source = os.statvfs(INSTALL_TREE)
self.source_size = source.f_frsize * (source.f_blocks -
source.f_bfree)
