new approach for blockdevice detection and handling

src/cryptobox/core/blockdevice.py

@@ -0,0 +1,230 @@
+#
+# Copyright 2007 sense.lab e.V.
+# 
+# This file is part of the CryptoBox.
+#
+# The CryptoBox is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# 
+# The CryptoBox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with the CryptoBox; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+
+'''
+These classes detect and filter available blockdevices.
+'''
+
+__revision__ = "$Id$"
+
+
+"""
+TODO:
+    - implement some caching
+    - find the devnodes for each device (e.g. /dev/hda)
+    - detect luks devices
+    - detect LVM
+"""
+
+
+import os
+
+class Blockdevices:
+    
+    def __init__(self, sysblock_dir='/sys/block', devnode_dir='/dev'):
+        self.sysblock_dir = sysblock_dir
+        self.devnode_dir = devnode_dir
+        self.devices = []
+        for devdir in find_blockdevices(self.sysblock_dir):
+            blockdevice = Blockdevice(devdir, self.devnode_dir)
+            if not blockdevice is None:
+                self.devices.append(blockdevice)
+
+
+    def get_devices(self):
+        """return a copy of the device list
+        """
+        return self.devices[:]
+
+
+
+
+class Blockdevice:
+
+    def __init__(self, dev, devnode_dir='/dev', sysblock_dir='/sys/block'):
+        self.devnode_dir = devnode_dir
+        self.sysblock_dir = sysblock_dir
+        if os.path.isabs(dev):
+            self.devdir = dev
+        else:
+            self.devdir = self.__find_relative_device(dev)
+            if self.devdir is None:
+                self = None
+                return
+        self.name = os.path.basename(self.devdir)
+        self.devnum = self.__get_major_minor()
+        ## check valid devnum
+        try:
+            major, minor = self.devnum
+        except TypeError:
+            self = None
+            return
+        self.size = self.__get_size()
+        self.range = self.__get_device_range()
+        self.slaves = self.__get_dev_related("slaves")
+        self.holders = self.__get_dev_related("holders")
+        self.children = self.__get_children()
+
+
+    def isstorage(self):
+        if self.range > 1:
+            ## partitionable blockdevice
+            return False
+        if self.size < 20:
+            ## extended partition, unused loop device
+            return False
+        if self.devnum[0] == 1:
+            ## ram device
+            return False
+        if self.children:
+            ## a parent blockdevice
+            return False
+        return True
+
+
+    def ispartitionable(self):
+        if self.range > 1:
+            return True
+        
+
+    def __find_relative_device(self, devname):
+        for devdir in find_blockdevices(self.sysblock_dir):
+            if os.path.basename(devdir) == devname:
+                return devdir
+        return None
+
+
+    def __get_dev_related(self, subdir):
+        """return the content of sub directories (e.g. 'holders' or 'slaves')
+        """
+        try:
+            return os.listdir(os.path.join(self.devdir, subdir))
+        except OSError:
+            return []
+
+
+    def __get_size(self):
+        default = 0
+        try:
+            return int(file(os.path.join(self.devdir, 'size')).read())
+        except OSError:
+            return default
+        except ValueError:
+            return default
+
+
+    def __get_major_minor(self):
+        """return the major and minor of the device"""
+        default = (0 ,0)
+        try:
+            content = file(os.path.join(self.devdir, "dev")).read()
+        except IOError:
+            return default
+        major, minor = content.split(":", 2)
+        try:
+            return int(major), int(minor)
+        except ValueError:
+            return default
+
+
+    def __get_device_range(self):
+        """number of possible subdevices
+
+        partitionable blockdevices have a range > 1
+        """
+        default = 1
+        try:
+            content = file(os.path.join(self.devdir, "range")).read()
+        except IOError:
+            return default
+        try:
+            return int(content)
+        except ValueError:
+            return default
+
+    
+    def __get_children(self):
+        """return all devices depending on the current one
+        
+        all holders, subdevices and children of subdevices
+        """
+        direct_children = [Blockdevice(child).name
+                for child in find_blockdevices(self.devdir)]
+        direct_children.extend(self.holders[:])
+        children = direct_children[:]
+        for dchild in direct_children:
+            children.extend(Blockdevice(dchild).children)
+        return children
+
+
+    def __str__(self):
+        return self.name
+
+
+    def info(self):
+        output = "%s:\n" % self.name
+        output += "\t%s:\t%s\n" % ("blockdir", self.devdir)
+        output += "\t%s:\t%s\n" % ("major/minor", self.devnum)
+        output += "\t%s:\t\t%s\n" % ("range", self.range)
+        output += "\t%s:\t\t%s\n" % ("size", self.size)
+        output += "\t%s:\t\t%s\n" % ("slaves", self.slaves)
+        output += "\t%s:\t%s\n" % ("holders", self.holders)
+        output += "\t%s:\t%s\n" % ("children", self.children)
+        return output
+
+
+
+def find_blockdevices(top_dir):
+
+    dev_dirs = []
+    
+    def look4dev_dirs(arg, dirname, fnames):
+        ## ignore the top level directory to avoid infinite recursion for
+        ## get_children
+        if os.path.samefile(dirname, top_dir):
+            return
+        ## add directories containing the file 'dev' to the list
+        if (arg in fnames) and os.path.isfile(os.path.join(dirname, arg)):
+            dev_dirs.append(dirname)
+        for fname in fnames:
+            ## remove symlinks and non-directories
+            fullname = os.path.join(dirname, fname)
+            if os.path.islink(fullname) or (not os.path.isdir(fullname)):
+                fnames.remove(fname)
+    
+    os.path.walk(top_dir, look4dev_dirs, 'dev')
+    return dev_dirs
+
+
+if __name__ == '__main__':
+    blocks = Blockdevices()
+    for dev in blocks.get_devices():
+        print dev.info()
+    print
+    print "Usable storage devices:"
+    for dev in blocks.get_devices():
+        if dev.isstorage():
+            print dev
+    print
+    print "Partitionable devices:"
+    for dev in blocks.get_devices():
+        if dev.ispartitionable():
+            print dev
+