def addDriver(self, widget, *args):
try:
self.scanForDriverDisk()
except InvalidDriverCDException, e:
util.umount(MEDIA_DEVICE_MOUNT_POINT)
cdutil.ejectCdrom()
MessageWindow(None, "Invalid Driver CD", str(e))
def findUSBMedia(showAll=False):
"""Scan attached USB devices for installation media.
If showAll is True, all CD devices are returned even if they do not contain
any installation media.
"""
diskSet = devices.DiskSet(forceReprobe=True)
retval = []
util.umount(USB_MEDIA_PATH)
for disk in diskSet.values():
if disk.driverName != devices.DiskDev.DRIVER_USB_STORAGE:
log.debug("skipping non-usb device -- %s" % disk.name)
continue
diskMedia = []
for part in disk.partitions:
if not part.consoleDevicePath:
continue
diskMedia += _tryDevice(disk, part)
if not diskMedia and showAll:
# No installation media was found on the device, but the caller
# wants the list of potential media devices, so add that in.
diskMedia = [media.MediaDescriptor(disk.name)]
retval += diskMedia
return retval
def test_fusexmp_fh(tmpdir, name):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = [os.path.join(basename, 'example', name),
'-f', '-o' , 'use_ino,readdir_ino,kernel_cache',
mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
work_dir = os.path.join(mnt_dir, src_dir)
tst_write(work_dir)
tst_mkdir(work_dir)
tst_symlink(work_dir)
tst_mknod(work_dir)
if os.getuid() == 0:
tst_chown(work_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(work_dir, ns_tol=1000)
tst_link(work_dir)
tst_readdir(work_dir)
tst_statvfs(work_dir)
tst_truncate_path(work_dir)
tst_truncate_fd(work_dir)
tst_unlink(work_dir)
tst_passthrough(src_dir, work_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_notify_inval_entry(tmpdir, notify, output_checker):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'notify_inval_entry'),
'-f', '--update-interval=1',
'--timeout=5', mnt_dir ]
if not notify:
cmdline.append('--no-notify')
mount_process = subprocess.Popen(cmdline,
stdout=output_checker.fd,
stderr=output_checker.fd)
try:
wait_for_mount(mount_process, mnt_dir)
fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
try:
os.stat(fname)
except FileNotFoundError:
# We may have hit a race condition and issued
# readdir just before the name changed
fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
os.stat(fname)
safe_sleep(2)
if not notify:
os.stat(fname)
safe_sleep(5)
with pytest.raises(FileNotFoundError):
os.stat(fname)
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_tmpfs(tmpdir):
mnt_dir = str(tmpdir)
cmdline = [sys.executable,
os.path.join(basename, 'examples', 'tmpfs.py'),
mnt_dir ]
mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL,
universal_newlines=True)
try:
wait_for_mount(mount_process, mnt_dir)
tst_write(mnt_dir)
tst_mkdir(mnt_dir)
tst_symlink(mnt_dir)
tst_mknod(mnt_dir)
tst_chown(mnt_dir)
tst_chmod(mnt_dir)
tst_utimens(mnt_dir)
tst_link(mnt_dir)
tst_readdir(mnt_dir)
tst_statvfs(mnt_dir)
tst_truncate_path(mnt_dir)
tst_truncate_fd(mnt_dir)
tst_unlink(mnt_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def _bootpartOption(match):
uuid = match.group(1)
if not util.uuidToDevicePath(uuid):
failWithLog("error: cannot find device for UUID: %s\n" % uuid)
userchoices.setBootUUID(uuid)
mountPath = util.mountByUuid(uuid)
if not mountPath:
failWithLog("error: cannot mount boot partition with UUID -- %s" % uuid)
restoredGrubConf = False
for prefix in ("boot/grub", "grub"):
path = os.path.join(mountPath, prefix, "grub.conf")
if os.path.exists(path):
tmpPath = os.tempnam(os.path.dirname(path), "grub.conf")
os.symlink(os.path.basename(GRUB_CONF_PREV), tmpPath)
# Use rename so the replacement is atomic.
os.rename(tmpPath, path)
restoredGrubConf = True
break
if not restoredGrubConf:
log.warn("could not restore %s, upgrade failure will not "
"reboot into ESX v3" % GRUB_CONF_PREV)
util.umount(mountPath)
return []
def _tryDevice(disk, part):
devicePath = part.consoleDevicePath
log.info("looking for installation data on %s" % devicePath)
# Either the USB storage is the media itself or it might contain an ISO file
# that is the installation media.
usbDesc = media.MediaDescriptor(disk.name, devicePath,
part.getFsTypeName())
if usbDesc.probeForPackages():
log.info(" found installation media...")
return [usbDesc]
# Be explicit about fsTypeName since long file names work if we mount it as
# "vfat", but not when the auto-detection thinks it's "msdos".
if util.mount(devicePath, USB_MEDIA_PATH,
fsTypeName=part.getFsTypeName()) != 0:
return []
retval = []
for iso in glob.glob(os.path.join(USB_MEDIA_PATH, "*.iso")):
isoDesc = media.MediaDescriptor(disk.name, devicePath,
part.getFsTypeName(),
os.path.basename(iso))
if isoDesc.probeForPackages():
log.info(" found iso, %s, with installation media..." % iso)
retval.append(isoDesc)
util.umount(USB_MEDIA_PATH)
return retval
def test_null(tmpdir, output_checker):
progname = pjoin(basename, 'example', 'null')
if not os.path.exists(progname):
pytest.skip('%s not built' % os.path.basename(progname))
mnt_file = str(tmpdir) + '/file'
with open(mnt_file, 'w') as fh:
fh.write('dummy')
cmdline = base_cmdline + [progname, '-f', mnt_file]
mount_process = subprocess.Popen(cmdline,
stdout=output_checker.fd,
stderr=output_checker.fd)
def test_fn(name):
return os.stat(name).st_size > 4000
try:
wait_for_mount(mount_process, mnt_file, test_fn)
with open(mnt_file, 'rb') as fh:
assert fh.read(382) == b'\0' * 382
with open(mnt_file, 'wb') as fh:
fh.write(b'whatever')
except:
cleanup(mount_process, mnt_file)
raise
else:
umount(mount_process, mnt_file)
def testfs(tmpdir):
# We can't use forkserver because we have to make sure
# that the server inherits the per-test stdout/stderr file
# descriptors.
if hasattr(multiprocessing, 'get_context'):
mp = multiprocessing.get_context('fork')
else:
# Older versions only support *fork* anyway
mp = multiprocessing
if threading.active_count() != 1:
raise RuntimeError("Multi-threaded test running is not supported")
mnt_dir = str(tmpdir)
with mp.Manager() as mgr:
cross_process = mgr.Namespace()
mount_process = mp.Process(target=run_fs,
args=(mnt_dir, cross_process))
mount_process.start()
try:
wait_for_mount(mount_process, mnt_dir)
yield (mnt_dir, cross_process)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def __init__(self, controlState, xml):
controlState.displayHeaderBar = True
controlState.windowIcon = 'customdrivers.png'
controlState.windowTitle = 'Custom Drivers'
controlState.windowText = \
'Select custom drivers to install for ESX'
self.xml = xml
self.foundDriverList = []
self.driverList = [] # list of drivers to save
self.driverDict = {} # cache of driver data
connectSignalHandlerByDict(self, CustomDriversWindow, self.xml,
{ ('CustomdriversNoRadioButton', 'toggled') : 'toggleDrivers',
('CustomdriversAddButton', 'clicked') : 'addDriver',
('CustomdriversRemoveButton', 'clicked') : 'removeDriver',
})
if userchoices.getDriversLoaded():
self.xml.get_widget('CustomdriversVBox').set_sensitive(False)
self.view = self.xml.get_widget('CustomdriversTreeView')
self.scrolled = self.xml.get_widget('CustomdriversScrolledWindow')
self.addDrivers = AddDrivers(self)
_setupAddDriversView(self.view)
# build up self.driverList in case the user has gone back
# from the screen and re-entered it
self.buildDriverList()
# unmount the cdrom so the user can eject it manually
util.umount(MEDIA_DEVICE_MOUNT_POINT)
def test_hello(tmpdir, name, options):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', mnt_dir ] + options
if name == 'hello_ll':
# supports single-threading only
cmdline.append('-s')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
assert os.listdir(mnt_dir) == ['hello']
filename = pjoin(mnt_dir, 'hello')
with open(filename, 'r') as fh:
assert fh.read() == 'Hello World!\n'
with pytest.raises(IOError) as exc_info:
open(filename, 'r+')
assert exc_info.value.errno == errno.EACCES
with pytest.raises(IOError) as exc_info:
open(filename + 'does-not-exist', 'r+')
assert exc_info.value.errno == errno.ENOENT
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_passthroughfs(tmpdir):
mnt_dir = str(tmpdir.mkdir("mnt"))
src_dir = str(tmpdir.mkdir("src"))
cmdline = [sys.executable, os.path.join(basename, "examples", "passthroughfs.py"), src_dir, mnt_dir]
mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)
try:
wait_for_mount(mount_process, mnt_dir)
tst_write(mnt_dir)
tst_mkdir(mnt_dir)
tst_symlink(mnt_dir)
tst_mknod(mnt_dir)
if os.getuid() == 0:
tst_chown(mnt_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(mnt_dir, ns_tol=1000)
tst_link(mnt_dir)
tst_readdir(mnt_dir)
tst_statvfs(mnt_dir)
tst_truncate(mnt_dir)
tst_passthrough(src_dir, mnt_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_notify1(tmpdir, name, notify):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', '--update-interval=1', mnt_dir ]
if not notify:
cmdline.append('--no-notify')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
filename = pjoin(mnt_dir, 'current_time')
with open(filename, 'r') as fh:
read1 = fh.read()
safe_sleep(2)
with open(filename, 'r') as fh:
read2 = fh.read()
if notify:
assert read1 != read2
else:
assert read1 == read2
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_fusexmp_fh(tmpdir, name):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = [os.path.join(basename, 'example', name),
'-f', '-o' , 'use_ino,readdir_ino,kernel_cache',
mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
work_dir = os.path.join(mnt_dir, src_dir)
tst_write(work_dir)
tst_mkdir(work_dir)
tst_symlink(work_dir)
tst_mknod(work_dir)
if os.getuid() == 0:
tst_chown(work_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(work_dir, ns_tol=1000)
tst_link(work_dir)
tst_readdir(work_dir)
tst_statvfs(work_dir)
tst_truncate_path(work_dir)
tst_truncate_fd(work_dir)
tst_unlink(work_dir)
tst_passthrough(src_dir, work_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_ioctl(tmpdir):
progname = pjoin(basename, 'example', 'ioctl')
if not os.path.exists(progname):
pytest.skip('%s not built' % os.path.basename(progname))
mnt_dir = str(tmpdir)
testfile = pjoin(mnt_dir, 'fioc')
cmdline = base_cmdline + [progname, '-f', mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'ioctl_client'),
testfile ]
assert subprocess.check_output(cmdline) == b'0\n'
with open(testfile, 'wb') as fh:
fh.write(b'foobar')
assert subprocess.check_output(cmdline) == b'6\n'
subprocess.check_call(cmdline + [ '3' ])
with open(testfile, 'rb') as fh:
assert fh.read()== b'foo'
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_notify_file_size(tmpdir, notify, output_checker):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'invalidate_path'),
'-f', '--update-interval=1', mnt_dir ]
if not notify:
cmdline.append('--no-notify')
mount_process = subprocess.Popen(cmdline,
stdout=output_checker.fd,
stderr=output_checker.fd)
try:
wait_for_mount(mount_process, mnt_dir)
filename = pjoin(mnt_dir, 'growing')
size = os.path.getsize(filename)
safe_sleep(2)
new_size = os.path.getsize(filename)
if notify:
assert new_size > size
else:
assert new_size == size
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def findUSBMedia(showAll=False):
"""Scan attached USB devices for installation media.
If showAll is True, all CD devices are returned even if they do not contain
any installation media.
"""
diskSet = devices.DiskSet(forceReprobe=True)
retval = []
util.umount(USB_MEDIA_PATH)
for disk in diskSet.values():
if disk.driverName != devices.DiskDev.DRIVER_USB_STORAGE:
log.debug("skipping non-usb device -- %s" % disk.name)
continue
diskMedia = []
for part in disk.partitions:
if not part.consoleDevicePath:
continue
diskMedia += _tryDevice(disk, part)
if not diskMedia and showAll:
# No installation media was found on the device, but the caller
# wants the list of potential media devices, so add that in.
diskMedia = [media.MediaDescriptor(disk.name)]
retval += diskMedia
return retval
def testfs(tmpdir):
# We can't use forkserver because we have to make sure
# that the server inherits the per-test stdout/stderr file
# descriptors.
if hasattr(multiprocessing, 'get_context'):
mp = multiprocessing.get_context('fork')
else:
# Older versions only support *fork* anyway
mp = multiprocessing
if threading.active_count() != 1:
raise RuntimeError("Multi-threaded test running is not supported")
mnt_dir = str(tmpdir)
with mp.Manager() as mgr:
cross_process = mgr.Namespace()
mount_process = mp.Process(target=run_fs,
args=(mnt_dir, cross_process))
mount_process.start()
try:
wait_for_mount(mount_process, mnt_dir)
yield (mnt_dir, cross_process)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_passthroughfs(tmpdir):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = [sys.executable,
os.path.join(basename, 'examples', 'passthroughfs.py'),
src_dir, mnt_dir ]
mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL,
universal_newlines=True)
try:
wait_for_mount(mount_process, mnt_dir)
tst_write(mnt_dir)
tst_mkdir(mnt_dir)
tst_symlink(mnt_dir)
tst_mknod(mnt_dir)
if os.getuid() == 0:
tst_chown(mnt_dir)
tst_chmod(mnt_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(mnt_dir, ns_tol=1000)
tst_rounding(mnt_dir)
tst_link(mnt_dir)
tst_readdir(mnt_dir)
tst_statvfs(mnt_dir)
tst_truncate_path(mnt_dir)
tst_truncate_fd(mnt_dir)
tst_unlink(mnt_dir)
tst_passthrough(src_dir, mnt_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def _tryDevice(disk, part):
devicePath = part.consoleDevicePath
log.info("looking for installation data on %s" % devicePath)
# Either the USB storage is the media itself or it might contain an ISO file
# that is the installation media.
usbDesc = media.MediaDescriptor(disk.name, devicePath, part.getFsTypeName())
if usbDesc.probeForPackages():
log.info(" found installation media...")
return [usbDesc]
# Be explicit about fsTypeName since long file names work if we mount it as
# "vfat", but not when the auto-detection thinks it's "msdos".
if util.mount(devicePath,
USB_MEDIA_PATH,
fsTypeName=part.getFsTypeName()) != 0:
return []
retval = []
for iso in glob.glob(os.path.join(USB_MEDIA_PATH, "*.iso")):
isoDesc = media.MediaDescriptor(
disk.name,
devicePath, part.getFsTypeName(),
os.path.basename(iso))
if isoDesc.probeForPackages():
log.info(" found iso, %s, with installation media..." % iso)
retval.append(isoDesc)
util.umount(USB_MEDIA_PATH)
return retval
def test_hello(tmpdir, name, options):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', mnt_dir ] + options
if name == 'hello_ll':
# supports single-threading only
cmdline.append('-s')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
assert os.listdir(mnt_dir) == [ 'hello' ]
filename = pjoin(mnt_dir, 'hello')
with open(filename, 'r') as fh:
assert fh.read() == 'Hello World!\n'
with pytest.raises(IOError) as exc_info:
open(filename, 'r+')
assert exc_info.value.errno == errno.EACCES
with pytest.raises(IOError) as exc_info:
open(filename + 'does-not-exist', 'r+')
assert exc_info.value.errno == errno.ENOENT
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_notify_inval_entry(tmpdir, notify):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'notify_inval_entry'),
'-f', '--update-interval=1',
'--timeout=5', mnt_dir ]
if not notify:
cmdline.append('--no-notify')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
try:
os.stat(fname)
except FileNotFoundError:
# We may have hit a race condition and issued
# readdir just before the name changed
fname = pjoin(mnt_dir, os.listdir(mnt_dir)[0])
os.stat(fname)
safe_sleep(2)
if not notify:
os.stat(fname)
safe_sleep(5)
with pytest.raises(FileNotFoundError):
os.stat(fname)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_ioctl(tmpdir, output_checker):
progname = pjoin(basename, 'example', 'ioctl')
if not os.path.exists(progname):
pytest.skip('%s not built' % os.path.basename(progname))
mnt_dir = str(tmpdir)
testfile = pjoin(mnt_dir, 'fioc')
cmdline = base_cmdline + [progname, '-f', mnt_dir]
mount_process = subprocess.Popen(cmdline,
stdout=output_checker.fd,
stderr=output_checker.fd)
try:
wait_for_mount(mount_process, mnt_dir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'ioctl_client'),
testfile ]
assert subprocess.check_output(cmdline) == b'0\n'
with open(testfile, 'wb') as fh:
fh.write(b'foobar')
assert subprocess.check_output(cmdline) == b'6\n'
subprocess.check_call(cmdline + ['3'])
with open(testfile, 'rb') as fh:
assert fh.read() == b'foo'
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_tmpfs(tmpdir):
mnt_dir = str(tmpdir)
cmdline = [sys.executable,
os.path.join(basename, 'examples', 'tmpfs.py'),
mnt_dir ]
mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL,
universal_newlines=True)
try:
wait_for_mount(mount_process, mnt_dir)
tst_write(mnt_dir)
tst_mkdir(mnt_dir)
tst_symlink(mnt_dir)
tst_mknod(mnt_dir)
tst_chown(mnt_dir)
tst_chmod(mnt_dir)
tst_utimens(mnt_dir)
tst_rounding(mnt_dir)
tst_link(mnt_dir)
tst_readdir(mnt_dir)
tst_statvfs(mnt_dir)
tst_truncate_path(mnt_dir)
tst_truncate_fd(mnt_dir)
tst_unlink(mnt_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def testfs(tmpdir):
# We can't use forkserver or spawn because of
# https://github.com/pytest-dev/pytest/issues/958.
if hasattr(multiprocessing, 'get_context'):
mp = multiprocessing.get_context('fork')
else:
# Older versions only support *fork* anyway
mp = multiprocessing
if threading.active_count() != 1:
raise RuntimeError("Multi-threaded test running is not supported")
mnt_dir = str(tmpdir)
with mp.Manager() as mgr:
cross_process = mgr.Namespace()
mount_process = mp.Process(target=run_fs,
args=(mnt_dir, cross_process))
mount_process.start()
try:
wait_for_mount(mount_process, mnt_dir)
yield (mnt_dir, cross_process)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_hello(tmpdir, filename):
mnt_dir = str(tmpdir)
cmdline = [
sys.executable,
os.path.join(basename, 'examples', filename), mnt_dir
]
mount_process = subprocess.Popen(cmdline,
stdin=subprocess.DEVNULL,
universal_newlines=True)
try:
wait_for_mount(mount_process, mnt_dir)
assert os.listdir(mnt_dir) == ['message']
filename = os.path.join(mnt_dir, 'message')
with open(filename, 'r') as fh:
assert fh.read() == 'hello world\n'
with pytest.raises(IOError) as exc_info:
open(filename, 'r+')
assert exc_info.value.errno == errno.EACCES
with pytest.raises(IOError) as exc_info:
open(filename + 'does-not-exist', 'r+')
assert exc_info.value.errno == errno.ENOENT
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def umount(self):
"""
Mount the media
"""
_debug_('Unmounting disc in drive %s' % self.drivename, 2)
util.umount(self.mountdir)
return
def test_notify1(tmpdir, name, notify):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', '--update-interval=1', mnt_dir ]
if not notify:
cmdline.append('--no-notify')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
filename = pjoin(mnt_dir, 'current_time')
with open(filename, 'r') as fh:
read1 = fh.read()
safe_sleep(2)
with open(filename, 'r') as fh:
read2 = fh.read()
if notify:
assert read1 != read2
else:
assert read1 == read2
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def finish(self):
if self.start_count == 0:
return
self.start_count -= 1
if self.start_count == 0:
util.umount(self.location)
os.rmdir(self.location)
self.location = None
def remove(self):
if self.mount:
util.umount(self.mount, self.istate.mount_points)
elif not self.keep:
for f in self.installed:
d = os.path.dirname(f)
os.unlink(f)
if len( os.listdir(d) ) == 0:
os.rmdir(d)
def umount(self):
if not self.isMounted:
return
util.umount(MEDIA_DEVICE_MOUNT_POINT)
if self.partPath:
util.umount(MEDIA_PATH)
self.isMounted = False
def test_passthrough(tmpdir, name, debug, capfd):
# Avoid false positives from libfuse debug messages
if debug:
capfd.register_output(r'^ unique: [0-9]+, error: -[0-9]+ .+$',
count=0)
# test_syscalls prints "No error" under FreeBSD
capfd.register_output(r"^ \d\d \[[^\]]+ message: 'No error: 0'\]", count=0)
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', mnt_dir ]
if debug:
cmdline.append('-d')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
work_dir = mnt_dir + src_dir
tst_statvfs(work_dir)
tst_readdir(src_dir, work_dir)
tst_open_read(src_dir, work_dir)
tst_open_write(src_dir, work_dir)
tst_create(work_dir)
tst_passthrough(src_dir, work_dir)
tst_append(src_dir, work_dir)
tst_seek(src_dir, work_dir)
tst_mkdir(work_dir)
tst_rmdir(src_dir, work_dir)
tst_unlink(src_dir, work_dir)
tst_symlink(work_dir)
if os.getuid() == 0:
tst_chown(work_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(work_dir, ns_tol=1000)
tst_link(work_dir)
tst_truncate_path(work_dir)
tst_truncate_fd(work_dir)
tst_open_unlink(work_dir)
subprocess.check_call([
os.path.join(basename, 'test', 'test_syscalls'), work_dir,
':' + src_dir
])
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_passthrough(tmpdir, name, debug, capfd):
# Avoid false positives from libfuse debug messages
if debug:
capfd.register_output(r'^ unique: [0-9]+, error: -[0-9]+ .+$',
count=0)
# test_syscalls prints "No error" under FreeBSD
capfd.register_output(r"^ \d\d \[[^\]]+ message: 'No error: 0'\]",
count=0)
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', mnt_dir ]
if debug:
cmdline.append('-d')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
work_dir = mnt_dir + src_dir
tst_statvfs(work_dir)
tst_readdir(src_dir, work_dir)
tst_open_read(src_dir, work_dir)
tst_open_write(src_dir, work_dir)
tst_create(work_dir)
tst_passthrough(src_dir, work_dir)
tst_append(src_dir, work_dir)
tst_seek(src_dir, work_dir)
tst_mkdir(work_dir)
tst_rmdir(src_dir, work_dir)
tst_unlink(src_dir, work_dir)
tst_symlink(work_dir)
if os.getuid() == 0:
tst_chown(work_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(work_dir, ns_tol=1000)
tst_link(work_dir)
tst_truncate_path(work_dir)
tst_truncate_fd(work_dir)
tst_open_unlink(work_dir)
subprocess.check_call([ os.path.join(basename, 'test', 'test_syscalls'),
work_dir, ':' + src_dir ])
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def remove_sources(self):
for src in [x for x in self.sources if (x.keep and not x.mountable)]:
# Previous actions may have overwritten the source, so
# it needs to be reinstalled one last time.
src.install(root=self.target_root)
for src in self.sources:
src.remove()
for m in ("proc", "sys", "devpts", "dev"):
util.umount(self.aux_mounts[m], self.istate.mount_points)
for m in ("resolv.conf", "hosts"):
self.aux_sources[m].remove()
def test_passthrough_hp(tmpdir, cache):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'passthrough_hp'),
src_dir, mnt_dir ]
if not cache:
cmdline.append('--nocache')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
tst_statvfs(mnt_dir)
tst_readdir(src_dir, mnt_dir)
tst_readdir_big(src_dir, mnt_dir)
tst_open_read(src_dir, mnt_dir)
tst_open_write(src_dir, mnt_dir)
tst_create(mnt_dir)
tst_passthrough(src_dir, mnt_dir)
tst_append(src_dir, mnt_dir)
tst_seek(src_dir, mnt_dir)
tst_mkdir(mnt_dir)
tst_rmdir(src_dir, mnt_dir)
tst_unlink(src_dir, mnt_dir)
tst_symlink(mnt_dir)
if os.getuid() == 0:
tst_chown(mnt_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(mnt_dir, ns_tol=1000)
tst_link(mnt_dir)
tst_truncate_path(mnt_dir)
tst_truncate_fd(mnt_dir)
tst_open_unlink(mnt_dir)
# test_syscalls assumes that changes in source directory
# will be reflected immediately in mountpoint, so we
# can't use it.
if not cache:
syscall_test_cmd = [
os.path.join(basename, 'test', 'test_syscalls'), mnt_dir,
':' + src_dir
]
subprocess.check_call(syscall_test_cmd)
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def unmount(self):
if self.mountedServer:
# Use the nfs specific umount, since the busybox one does not work
# well with unreachable nfs servers.
nfsMountPoint = self.mountpoint
if self.mountedRoot.endswith('.iso'):
util.umount(self.mountpoint)
nfsMountPoint = "%s-isosrc" % self.mountpoint
command = '/sbin/umount.nfs'
argv = [command, nfsMountPoint, '-f']
execWithLog(command, argv, level=logging.DEBUG)
self.mountedServer = None
self.mountedRoot = None
def tidyActionUnmount():
requests = allUserPartitionRequests()
requests.sort(sortByMountPoint=True)
requests.reverse()
for request in requests:
if not request.mountPoint:
continue
mountPoint = os.path.normpath(consts.HOST_ROOT + request.mountPoint)
if os.path.exists(mountPoint):
log.debug("Unmounting %s" % (mountPoint))
util.umount(mountPoint)
def unmount(self):
if self.mountedServer:
# Use the nfs specific umount, since the busybox one does not work
# well with unreachable nfs servers.
nfsMountPoint = self.mountpoint
if self.mountedRoot.endswith('.iso'):
util.umount(self.mountpoint)
nfsMountPoint = "%s-isosrc" % self.mountpoint
command = '/sbin/umount.nfs'
argv = [command, nfsMountPoint, '-f']
execWithLog(command, argv, level=logging.DEBUG)
self.mountedServer = None
self.mountedRoot = None
def test_fsel(tmpdir):
mnt_dir = str(tmpdir)
cmdline = [os.path.join(basename, 'example', 'fsel'), '-f', mnt_dir]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
cmdline = [os.path.join(basename, 'example', 'fselclient')]
subprocess.check_call(cmdline, cwd=mnt_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_fsel(tmpdir):
mnt_dir = str(tmpdir)
cmdline = [os.path.join(basename, 'example', 'fsel'),
'-f', mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
cmdline = [ os.path.join(basename, 'example', 'fselclient') ]
subprocess.check_call(cmdline, cwd=mnt_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def setup_unreliablefs(tmpdir):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
options = "-basedir={}".format(src_dir)
cmdline = base_cmdline + [
pjoin(basename, 'build/unreliablefs'), mnt_dir, options
]
mount_process = subprocess.Popen(cmdline)
wait_for_mount(mount_process, mnt_dir)
yield mnt_dir, src_dir
umount(mount_process, mnt_dir)
cleanup(mount_process, mnt_dir)
def test_poll(tmpdir, output_checker):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + [pjoin(basename, 'example', 'poll'),
'-f', mnt_dir ]
mount_process = subprocess.Popen(cmdline, stdout=output_checker.fd,
stderr=output_checker.fd)
try:
wait_for_mount(mount_process, mnt_dir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'poll_client') ]
subprocess.check_call(cmdline, cwd=mnt_dir)
except:
cleanup(mount_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def umountEject(uMountPoint):
"""Attempt to reliably unmount the media and eject it. This can
be kludgey. umount on some systems doesn't free up the resource
that eject thinks has to be free.
"""
# TODO AND NOTES:
# 1. Deliberately inserting the wrong CD can lead to duplicate mounts,
# and later umount trouble. Workaround: select a separate console,
# and manually umount. Need to bullet-proof this better.
# 2. umount immediately followed by eject has been known to failed
# on certain other Busybox/uClibc/2.4kernel systems. Injecting a sleep
# works around the problem.
import time
for trial in (1, 2, 3):
if uMountPoint: # guard against NoneType, ''
status = util.umount(uMountPoint)
if status == 0: # success
break
else:
args = ["/usr/bin/umount", "-f", uMountPoint]
status = util.execWithLog(args[0], args)
log.warn('Forced umount of %s: %d' % (uMountPoint, status))
time.sleep(1)
log.warn('customdrivers_ui umount attempt %d failed' % trial)
status = cdutil.ejectCdrom()
return status
def testfs(tmpdir):
mnt_dir = str(tmpdir)
mp = get_mp()
with mp.Manager() as mgr:
cross_process = mgr.Namespace()
mount_process = mp.Process(target=run_fs,
args=(mnt_dir, cross_process))
mount_process.start()
try:
wait_for_mount(mount_process, mnt_dir)
yield (mnt_dir, cross_process)
except:
cleanup(mnt_process, mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def _usbOption(match):
'''Handle the "ks=usb" and "ks=usb:<path>" option.'''
try:
ksFile = match.group(1)
except IndexError:
ksFile = "ks.cfg"
firstTime = True
while True:
if not firstTime:
# XXX Maybe we should just stop retrying after awhile?
log.info("Insert a USB storage device that contains '%s' "
"file to perform a scripted install..." % ksFile)
util.rawInputCountdown("\rrescanning in %2d second(s), "
"press <enter> to rescan immediately", 10)
firstTime = False
diskSet = devices.DiskSet(forceReprobe=True)
usbDisks = [disk for disk in diskSet.values()
if disk.driverName == devices.DiskDev.DRIVER_USB_STORAGE]
if not usbDisks:
log.info("") # XXX just for spacing
log.warn("No USB storage found.")
continue
kickstartPath = os.path.join(USB_MOUNT_PATH, ksFile.lstrip('/'))
if not os.path.exists(USB_MOUNT_PATH):
os.makedirs(USB_MOUNT_PATH)
for disk in usbDisks:
for part in disk.partitions:
if part.partitionId == -1:
continue
if (part.getFsTypeName() not in ("ext2", "ext3", "vfat")):
# Don't try mounting partitions with filesystems that aren't
# likely to be on a usb key.
continue
if util.mount(part.consoleDevicePath,
USB_MOUNT_PATH,
fsTypeName=part.getFsTypeName()):
log.warn("Unable to mount '%s'" % part.consoleDevicePath)
continue
if os.path.exists(kickstartPath):
userchoices.addDriveUse(disk.name, 'kickstart')
return [('-s', kickstartPath)]
if util.umount(USB_MOUNT_PATH):
failWithLog("Unable to umount '%s'" % USB_MOUNT_PATH)
log.info("")
log.warn("%s was not found on any attached USB storage." % ksFile)
def _ksFileCdromOption(match):
path = match.group(1)
if not os.path.exists(CDROM_MOUNT_PATH):
os.makedirs(CDROM_MOUNT_PATH)
for cdPath in cdutil.cdromDevicePaths():
if util.mount(cdPath, CDROM_MOUNT_PATH):
log.warn("cannot mount cd-rom in %s" % cdPath)
continue
ksPath = os.path.join(CDROM_MOUNT_PATH, path.lstrip('/'))
if os.path.exists(ksPath):
return [('-s', ksPath)]
util.umount(CDROM_MOUNT_PATH)
failWithLog("cannot find kickstart file on cd-rom with path -- %s" % path)
def test_fuse(tmpdir):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = [ os.path.join(basename, 'example', 'fusexmp_fh'),
'-f', '-o' , 'use_ino,readdir_ino,kernel_cache',
mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
cmdline = [ os.path.join(basename, 'test', 'test'),
os.path.join(mnt_dir, src_dir),
':' + src_dir ]
subprocess.check_call(cmdline)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_lltest(tmpdir):
mnt_dir = str(tmpdir)
cmdline = [sys.executable, os.path.join(basename, "examples", "lltest.py"), mnt_dir]
mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True)
try:
wait_for_mount(mount_process, mnt_dir)
assert os.listdir(mnt_dir) == ["message"]
filename = os.path.join(mnt_dir, "message")
with open(filename, "r") as fh:
assert fh.read() == "hello world\n"
with pytest.raises(IOError) as exc_info:
open(filename, "r+")
assert exc_info.value.errno == errno.EPERM
with pytest.raises(IOError) as exc_info:
open(filename + "does-not-exist", "r+")
assert exc_info.value.errno == errno.ENOENT
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_passthrough_ll(tmpdir, writeback, debug, capfd):
progname = pjoin(basename, 'example', 'passthrough_ll')
if not os.path.exists(progname):
pytest.skip('%s not built' % os.path.basename(progname))
# Avoid false positives from libfuse debug messages
if debug:
capfd.register_output(r'^ unique: [0-9]+, error: -[0-9]+ .+$',
count=0)
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = base_cmdline + [ progname, '-f', mnt_dir ]
if debug:
cmdline.append('-d')
if writeback:
cmdline.append('-o')
cmdline.append('writeback')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
work_dir = mnt_dir + src_dir
tst_statvfs(work_dir)
tst_readdir(src_dir, work_dir)
tst_open_read(src_dir, work_dir)
tst_open_write(src_dir, work_dir)
tst_create(work_dir)
tst_passthrough(src_dir, work_dir)
tst_append(src_dir, work_dir)
tst_seek(src_dir, work_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def bugtool(inst, dest_url):
try:
inst.mount_root(ro = False)
util.bindMount('/dev', os.path.join(inst.root_fs.mount_point, 'dev'))
util.bindMount('/proc', os.path.join(inst.root_fs.mount_point, 'proc'))
util.bindMount('/sys', os.path.join(inst.root_fs.mount_point, 'sys'))
os.environ['XEN_RT'] = '1'
os.environ['XENRT_BUGTOOL_BASENAME'] = 'offline-bugtool'
util.runCmd2(['chroot', inst.root_fs.mount_point, '/usr/sbin/xen-bugtool', '-y', '--unlimited'])
out_fname = os.path.join(inst.root_fs.mount_point, 'var/opt/xen/bug-report/offline-bugtool.tar.bz2')
util.umount(os.path.join(inst.root_fs.mount_point, 'sys'))
util.umount(os.path.join(inst.root_fs.mount_point, 'proc'))
util.umount(os.path.join(inst.root_fs.mount_point, 'dev'))
xcp.logger.log("Saving to " + dest_url)
a = xcp.accessor.createAccessor(dest_url, False)
a.start()
inh = open(out_fname)
a.writeFile(inh, 'offline-bugtool.tar.bz2')
inh.close()
a.finish()
os.remove(out_fname)
finally:
inst.unmount_root()
def test_hello(tmpdir, name):
mnt_dir = str(tmpdir)
cmdline = [os.path.join(basename, 'example', name),
'-f', mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
assert os.listdir(mnt_dir) == [ 'hello' ]
filename = os.path.join(mnt_dir, 'hello')
with open(filename, 'r') as fh:
assert fh.read() == 'Hello World!\n'
with pytest.raises(IOError) as exc_info:
open(filename, 'r+')
assert exc_info.value.errno == errno.EACCES
with pytest.raises(IOError) as exc_info:
open(filename + 'does-not-exist', 'r+')
assert exc_info.value.errno == errno.ENOENT
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_null(tmpdir):
progname = pjoin(basename, 'example', 'null')
if not os.path.exists(progname):
pytest.skip('%s not built' % os.path.basename(progname))
mnt_file = str(tmpdir) + '/file'
with open(mnt_file, 'w') as fh:
fh.write('dummy')
cmdline = base_cmdline + [ progname, '-f', mnt_file ]
mount_process = subprocess.Popen(cmdline)
def test_fn(name):
return os.stat(name).st_size > 4000
try:
wait_for_mount(mount_process, mnt_file, test_fn)
with open(mnt_file, 'rb') as fh:
assert fh.read(382) == b'\0' * 382
with open(mnt_file, 'wb') as fh:
fh.write(b'whatever')
except:
cleanup(mnt_file)
raise
else:
umount(mount_process, mnt_file)
def test_notify_file_size(tmpdir, notify):
mnt_dir = str(tmpdir)
cmdline = base_cmdline + \
[ pjoin(basename, 'example', 'invalidate_path'),
'-f', '--update-interval=1', mnt_dir ]
if not notify:
cmdline.append('--no-notify')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
filename = pjoin(mnt_dir, 'growing')
size = os.path.getsize(filename)
safe_sleep(2)
new_size = os.path.getsize(filename)
if notify:
assert new_size > size
else:
assert new_size == size
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_fioc(tmpdir):
mnt_dir = str(tmpdir)
testfile = os.path.join(mnt_dir, 'fioc')
cmdline = [os.path.join(basename, 'example', 'fioc'),
'-f', mnt_dir ]
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
base_cmd = [ os.path.join(basename, 'example', 'fioclient'),
testfile ]
assert subprocess.check_output(base_cmd) == b'0\n'
with open(testfile, 'wb') as fh:
fh.write(b'foobar')
assert subprocess.check_output(base_cmd) == b'6\n'
subprocess.check_call(base_cmd + [ '3' ])
with open(testfile, 'rb') as fh:
assert fh.read()== b'foo'
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_passthrough(tmpdir, name, debug):
mnt_dir = str(tmpdir.mkdir('mnt'))
src_dir = str(tmpdir.mkdir('src'))
cmdline = base_cmdline + \
[ pjoin(basename, 'example', name),
'-f', mnt_dir ]
if debug:
cmdline.append('-d')
mount_process = subprocess.Popen(cmdline)
try:
wait_for_mount(mount_process, mnt_dir)
work_dir = pjoin(mnt_dir, src_dir)
subprocess.check_call([ os.path.join(basename, 'test', 'test'),
work_dir, ':' + src_dir ])
tst_write(work_dir)
tst_mkdir(work_dir)
tst_symlink(work_dir)
tst_mknod(work_dir)
if os.getuid() == 0:
tst_chown(work_dir)
# Underlying fs may not have full nanosecond resolution
tst_utimens(work_dir, ns_tol=1000)
tst_link(work_dir)
tst_readdir(work_dir)
tst_statvfs(work_dir)
tst_truncate_path(work_dir)
tst_truncate_fd(work_dir)
tst_unlink(work_dir)
tst_passthrough(src_dir, work_dir)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def scanForDriverDisk(self):
'''Mount the CD-ROM and check to see if it is a driver CD.'''
self.foundDriverList = []
driverDict = {}
xmlFileName = os.path.join(MEDIA_DEVICE_MOUNT_POINT, "drivers.xml")
util.umount(MEDIA_DEVICE_MOUNT_POINT)
cdutil.ejectCdrom()
window = MessageWindow(None, "Insert CD", INSERT_DRIVER_CD_STRING,
type="okcancel")
if window.affirmativeResponse:
util.mount(CDROM_DEVICE_PATH, MEDIA_DEVICE_MOUNT_POINT)
if not os.path.exists(xmlFileName):
raise InvalidDriverCDException(INVALID_DRIVER_CD_STRING)
else:
return
try:
driverXml = customdrivers.CustomDriversXML(xmlFileName)
except customdrivers.InvalidVersion, msg:
raise InvalidDriverCDException(INVALID_VERSION_STRING)
def importClicked(self, widget, *args):
store, selected = self.view.get_selection().get_selected_rows()
if not selected:
MessageWindow(None, 'Driver Selection Error',
'You must select a driver to import.')
return
for entry in selected:
packageName = store[entry[0]][DRIVERMODEL_PACKAGE]
if _checkForCollision(packageName, self.parent.driverList,
self.parent.driverDict):
MessageWindow(None, 'Driver Import Error',
"Couldn't add the %s package due to a conflict." %
packageName)
continue
fileName = os.path.join(MEDIA_DEVICE_MOUNT_POINT, packageName)
assert os.path.exists(fileName)
targetFileName = \
os.path.join(customdrivers.DRIVER_DEPOT_DIR,
os.path.basename(packageName))
self.parent.driverList.append(tuple(store[entry[0]]))
self.parent.updateDriverList()
shutil.copy(fileName, targetFileName)
self.xml.get_widget('CustomdriversRemoveButton').set_sensitive(True)
# leave the CDROM unmounted so the user can eject it manually
util.umount(MEDIA_DEVICE_MOUNT_POINT)
self.hide()
