Thomas Gläßle avatar Thomas Gläßle committed d5e96e0

Relocate udiskie.umount.* to udiskie.mount.*

Keep udiskie.umount.* for backward compatibility.

Comments (0)

Files changed (3)

 
 import udiskie.match
 import udiskie.mount
-import udiskie.umount
 import udiskie.device
 import udiskie.prompt
 import udiskie.notify
     # print command line options
     else:
         parser.print_usage()
+        return 1
 
 
 def umount_program_options():
     """
     Execute the umount command.
     """
-    logger = logging.getLogger('udiskie.umount.cli')
-    (options, posargs) = umount_program_options().parse_args(args)
+    parser = umount_program_options()
+    (options, posargs) = parser.parse_args(args)
     logging.basicConfig(level=options.log_level, format='%(message)s')
+    bus = dbus.SystemBus()
+
+    if len(posargs) == 0 and not options.all:
+        parser.print_usage()
+        return 1
 
     if options.all:
-        unmounted = udiskie.umount.unmount_all()
+        unmounted = udiskie.mount.unmount_all(bus=bus)
     else:
-        if len(posargs) == 0:
-            logger.warn('No devices provided for unmount')
-            return 1
-
         unmounted = []
         for path in posargs:
-            device = udiskie.umount.unmount(os.path.normpath(path))
+            device = udiskie.mount.unmount(os.path.normpath(path), bus=bus)
             if device:
                 unmounted.append(device)
 
     # automatically lock unused luks slaves of unmounted devices
     for device in unmounted:
-        udiskie.umount.lock_slave(device)
+        udiskie.mount.lock_slave(device)
 
 Udiskie mount utilities.
 """
 __all__ = [
-    'mount_device', 'unlock_device', 'add_device',
-    'mount_all',
+    'mount_device', 'unmount_device',
+    'unlock_device', 'lock_device',
+    'add_device', 'remove_device',
+    'mount_all', 'unmount_all',
+    'unmount',
+    'lock_luks_slave',
     'Mounter']
 
 import logging
 import udiskie.device
 
 
+# mount/unmount
 def mount_device(device, filter=None):
     """
     Mount the device if not already mounted.
     mount_paths = ', '.join(device.mount_paths)
     return True
 
+def unmount_device(device):
+    """
+    Unmount a Device.
+
+    Checks to make sure the device is unmountable and then unmounts.
+    Return value indicates whether an action was performed successfully.
+    The special value `None` means unknown/unreliable.
+
+    """
+    logger = logging.getLogger('udiskie.mount.unmount_device')
+    if not device.is_handleable or not device.is_filesystem:
+        logger.debug('skipping unhandled device %s' % (device,))
+        return False
+    if not device.is_mounted:
+        logger.debug('skipping unmounted device %s' % (device,))
+        return False
+    try:
+        device.unmount()
+        logger.info('unmounted device %s' % (device,))
+    except dbus.exceptions.DBusException, dbus_err:
+        logger.error('failed to unmount device %s: %s' % (device,
+                                                            dbus_err))
+        return None
+    return True
+
+
+# unlock/lock (LUKS)
 def unlock_device(device, prompt):
     """
     Unlock the device if not already unlocked.
         return None
     return True
 
+def lock_device(device):
+    """
+    Lock device.
+
+    Checks to make sure the device is lockable, then locks.
+    Return value indicates whether an action was performed successfully.
+    The special value `None` means unknown/unreliable.
+
+    """
+    logger = logging.getLogger('udiskie.mount.lock_device')
+    if not device.is_handleable or not device.is_crypto:
+        logger.debug('skipping unhandled device %s' % (device,))
+        return False
+    if not device.is_unlocked:
+        logger.debug('skipping locked device %s' % (device,))
+        return False
+    try:
+        device.lock([])
+        logger.info('locked device %s' % (device,))
+    except dbus.exceptions.DBusException, dbus_err:
+        logger.error('failed to lock device %s: %s' % (device, dbus_err))
+        return None
+    return True
+
+
+# add/remove (unlock/lock or mount/unmount)
 def add_device(device, filter=None, prompt=None):
     """Mount or unlock the device depending on its type."""
     log = logging.getLogger('udiskie.mount.add_device')
     elif device.is_crypto:
         return unlock_device(device, prompt)
 
+def remove_device(device):
+    """Unmount or lock the device depending on device type."""
+    logger = logging.getLogger('udiskie.mount.remove_device')
+    if not device.is_handleable:
+        logger.debug('skipping unhandled device %s' % (device,))
+        return False
+    if device.is_filesystem:
+        return unmount_device(device)
+    elif device.is_crypto:
+        return lock_device(device)
+
+# mount_all/unmount_all
 def mount_all(bus=None, filter=None, prompt=None):
     """Mount handleable devices that are already present."""
     bus = bus or dbus.SystemBus()
     for device in udiskie.device.get_all_handleable(bus):
         add_device(device, filter, prompt)
 
+def unmount_all(bus=None):
+    """Unmount all filesystems handleable by udiskie."""
+    unmounted = []
+    bus = bus or dbus.SystemBus()
+    for device in udiskie.device.get_all_handleable(bus):
+        if unmount_device(device):
+            unmounted.append(device)
+    return unmounted
 
+
+# lock a slave
+def lock_slave(device):
+    """
+    Lock the luks slave of this device.
+
+    Will not lock the slave if it is still used by any mounted file system.
+    Return value indicates success.
+
+    """
+    logger = logging.getLogger('udiskie.mount.lock_slave')
+    if not device.is_luks_cleartext:
+        logger.debug('skipping non-luks-cleartext device %s' % (device,))
+        return False
+    slave_path = device.luks_cleartext_slave
+    slave = udiskie.device.Device(device.bus, slave_path)
+    if slave.is_luks_cleartext_slave:
+        return False
+    return lock_device(slave)
+
+
+# mount/unmount by path
+def unmount(path, bus=None):
+    """
+    Unmount or lock a filesystem
+
+    The filesystem must match the criteria for a filesystem mountable by
+    udiskie.  path is either the physical device node (e.g. /dev/sdb1) or the
+    mount point (e.g. /media/Foo).
+
+    """
+    logger = logging.getLogger('udiskie.mount.unmount')
+    bus = bus or dbus.SystemBus()
+    device = udiskie.device.get_device(bus, path)
+    if device:
+        logger.debug('found device owning "%s": "%s"' % (path, device))
+        if remove_device(device):
+            return device
+    return None
+
+
+# utility class
 class Mounter:
     """
     Mount utility.
         self.filter = filter
         self.prompt = prompt
 
+    # mount/unmount
     def mount_device(self, device, filter=None):
         return mount_device(device, filter=filter or self.filter)
+    def unmount_device(self, device):
+        return unmount_device(device)
 
+    # unlock/lock (LUKS)
     def unlock_device(self, device, prompt=None):
         return mount_device(device, filter=prompt or self.prompt)
+    def lock_device(self, device):
+        return lock_device(device)
 
+    # add/remove (unlock/lock or mount/unmount)
     def add_device(self, device, filter=None, prompt=None):
         return add_device(
                 device,
-                filter=filter or self.filter, 
+                filter=filter or self.filter,
                 prompt=prompt or self.prompt)
+    def remove_device(self, device):
+        return remove_device(device)
 
+    # mount_all/unmount_all
     def mount_all(self, filter=None, prompt=None):
         return mount_all(
                 self.bus,
                 filter=filter or self.filter,
                 prompt=prompt or self.prompt)
+    def unmount_all(self):
+        return unmount_all(self.bus)
 
+    # mount/unmount
+    def unmount(self, path):
+        return unmount(path, bus=self.bus)
 
+    # mount_holder/lock_slave
+    def lock_slave(self, device):
+        return lock_slave(device)
+

udiskie/umount.py

     'unmount_device', 'lock_device', 'remove_device', 'lock_slave',
     'unmount', 'unmount_all']
 
-import logging
-import dbus
+from udiskie.mount import unmount_device, lock_device, remove_device, lock_slave, unmount, unmount_all
 
-import udiskie.device
-
-def unmount_device(device):
-    """
-    Unmount a Device.
-
-    Checks to make sure the device is unmountable and then unmounts.
-    Return value indicates whether an action was performed successfully.
-    The special value `None` means unknown/unreliable.
-
-    """
-    logger = logging.getLogger('udiskie.umount.unmount_device')
-    if not device.is_handleable or not device.is_filesystem:
-        logger.debug('skipping unhandled device %s' % (device,))
-        return False
-    if not device.is_mounted:
-        logger.debug('skipping unmounted device %s' % (device,))
-        return False
-    try:
-        device.unmount()
-        logger.info('unmounted device %s' % (device,))
-    except dbus.exceptions.DBusException, dbus_err:
-        logger.error('failed to unmount device %s: %s' % (device,
-                                                            dbus_err))
-        return None
-    return True
-
-def lock_device(device):
-    """
-    Lock device.
-
-    Checks to make sure the device is lockable, then locks.
-    Return value indicates whether an action was performed successfully.
-    The special value `None` means unknown/unreliable.
-
-    """
-    logger = logging.getLogger('udiskie.umount.lock_device')
-    if not device.is_handleable or not device.is_crypto:
-        logger.debug('skipping unhandled device %s' % (device,))
-        return False
-    if not device.is_unlocked:
-        logger.debug('skipping locked device %s' % (device,))
-        return False
-    try:
-        device.lock([])
-        logger.info('locked device %s' % (device,))
-    except dbus.exceptions.DBusException, dbus_err:
-        logger.error('failed to lock device %s: %s' % (device, dbus_err))
-        return None
-    return True
-
-def remove_device(device):
-    """Unmount or lock the device depending on device type."""
-    logger = logging.getLogger('udiskie.umount.remove_device')
-    if not device.is_handleable:
-        logger.debug('skipping unhandled device %s' % (device,))
-        return False
-    if device.is_filesystem:
-        return unmount_device(device)
-    elif device.is_crypto:
-        return lock_device(device)
-
-def lock_slave(device):
-    """
-    Lock the luks slave of this device.
-
-    Will not lock the slave if it is still used by any mounted file system.
-    Return value indicates success.
-
-    """
-    logger = logging.getLogger('udiskie.umount.lock_slave')
-    if not device.is_luks_cleartext:
-        logger.debug('skipping non-luks-cleartext device %s' % (device,))
-        return False
-    slave_path = device.luks_cleartext_slave
-    slave = udiskie.device.Device(device.bus, slave_path)
-    if slave.is_luks_cleartext_slave:
-        return False
-    return lock_device(slave)
-
-
-def unmount(path):
-    """Unmount or lock a filesystem
-
-    The filesystem must match the criteria for a filesystem mountable by
-    udiskie.  path is either the physical device node (e.g. /dev/sdb1) or the
-    mount point (e.g. /media/Foo)."""
-
-    logger = logging.getLogger('udiskie.umount.unmount')
-    bus = dbus.SystemBus()
-
-    device = udiskie.device.get_device(bus, path)
-    if device:
-        logger.debug('found device owning "%s": "%s"' % (path, device))
-        if remove_device(device):
-            return device
-    return None
-
-
-def unmount_all():
-    """Unmount all filesystems handleable by udiskie."""
-    unmounted = []
-    bus = dbus.SystemBus()
-    for device in udiskie.device.get_all(bus):
-        if unmount_device(device):
-            unmounted.append(device)
-    return unmounted
-
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.