Add support for Join sets where the parity protects the split files
[rarslave2.git] / rarslave.py
old mode 100644 (file)
new mode 100755 (executable)
index 6532de5..20c0288
 #!/usr/bin/env python
 #!/usr/bin/env python
-# vim: set ts=4 sts=4 sw=4 textwidth=112 :
+# vim: set ts=4 sts=4 sw=4 textwidth=80:
+
+"""
+The main program of the rarslave project
+
+This handles all of the commandline and configuration file work, then tries to
+repair, extract, and delete any PAR2Sets that it finds.
+"""
+
+__author__    = "Ira W. Snyder (devel@irasnyder.com)"
+__copyright__ = "Copyright (c) 2006-2008 Ira W. Snyder (devel@irasnyder.com)"
+__license__   = "GNU GPL v2 (or, at your option, any later version)"
+
+#    rarslave.py -- a usenet autorepair and autoextract utility
+#
+#    Copyright (C) 2006-2008  Ira W. Snyder (devel@irasnyder.com)
+#
+#    This program 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.
+#
+#    This program 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 this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
-import re, os, sys
+VERSION = "2.1.0"
+PROGRAM = "rarslave"
 
 
-def get_basename (name):
-       """Strips most kinds of endings from a filename"""
+import os, sys, optparse, logging, ConfigParser
+from subprocess import CalledProcessError
+import PAR2Set
 
 
-       regex = '^(.+)\.(par2|vol\d+\+\d+|\d\d\d|part\d+|rar|zip|avi|mp4|mkv|ogm)$'
-       r = re.compile (regex, re.IGNORECASE)
-       done = False
+################################################################################
 
 
-       while not done:
-               done = True
+# A simple-ish configuration class
+class RarslaveConfig(object):
 
 
-               if r.match (name):
-                       g = r.match (name).groups()
-                       name = g[0]
-                       done = False
+    DEFAULT_CONFIG_FILE = PAR2Set.utils.absolutePath(
+        os.path.join('~', '.config', 'rarslave', 'rarslave.conf'))
 
 
-       return name
+    def __init__(self, fileName=DEFAULT_CONFIG_FILE):
 
 
-def find_likely_files (name, dir):
-       """Finds files which are likely to be part of the set corresponding
-          to $name in the directory $dir"""
+        # Make sure that the fileName is in absolute form
+        self.fileName = os.path.abspath(os.path.expanduser(fileName))
 
 
-       if not os.path.isdir (os.path.abspath (dir)):
-               raise ValueError # bad directory given
+        # Open it with ConfigParser
+        self.config = ConfigParser.SafeConfigParser()
+        self.config.read(fileName)
 
 
-       dir = os.path.abspath (dir)
-       ename = re.escape (name)
-       regex = re.compile ('^%s.*$' % (ename, ))
+        # Setup the default dictionary
+        self.defaults = dict()
 
 
-       return [f for f in os.listdir (dir) if regex.match (f)]
+        # Add all of the defaults
+        self.add_default('directories', 'start',
+                         os.path.join('~', 'downloads'),
+                         PAR2Set.utils.absolutePath)
+        self.add_default('options', 'recursive', True, self.toBool)
+        self.add_default('options', 'interactive', False, self.toBool)
+        self.add_default('options', 'verbosity', 0, self.toInt)
+        self.add_default('options', 'delete', True, self.toBool)
 
 
-def find_all_par2_files (dir):
-       """Finds all par2 files in a directory"""
+    # Add a new default value
+    def add_default(self, section, key, value, typeConverter):
 
 
-       if not os.path.isdir (os.path.abspath (dir)):
-               raise ValueError # bad directory given
+        self.defaults[(section, key)] = (value, typeConverter)
 
 
-       dir = os.path.abspath (dir)
-       regex = re.compile ('^.*\.par2$', re.IGNORECASE)
+    # Get the default value
+    def get_default(self, section, key):
 
 
-       # Find all files
-       return [f for f in os.listdir (dir) if regex.match (f)]
+        (value, typeConverter) = self.defaults[(section, key)]
+        return value
 
 
-def has_extension (f, ext):
-       """Checks if f has the extension ext"""
+    # Coerce the value from a string into the correct type
+    def coerceValue(self, section, key, value):
 
 
-       if ext[0] != '.':
-               ext = '.' + ext
+        (defaultValue, typeConverter) = self.defaults[(section, key)]
 
 
-       ext = re.escape (ext)
-       regex = re.compile ('^.*%s$' % (ext, ), re.IGNORECASE)
-       return regex.match (f)
+        # Try the coercion, error and exit if there is a problem
+        try:
+            return typeConverter(value)
+        except:
+            sys.stderr.write('Unable to parse configuration file\n')
+            sys.stderr.write('-> at section: %s\n' % section)
+            sys.stderr.write('-> at key: %s\n' % key)
+            sys.exit(2)
 
 
-def find_extraction_heads (files):
-       """Takes a list of possible files and finds likely heads of
-          extraction."""
+    # Return the value
+    def get(self, section, key):
 
 
-       # NOTE: perhaps this should happen AFTER repair is
-       # NOTE: successful. That way all files would already exist
+        try:
+            # Get the user-provided value
+            value = self.config.get(section, key)
+        except:
+            # Oops, they didn't provide it, use the default
+            # NOTE: if you get an exception here, check your code ;)
+            value = self.defaults[(section, key)]
 
 
-       # According to various sources online:
-       # 1) pre rar-3.0: .rar .r00 .r01 ...
-       # 2) post rar-3.0: .part01.rar .part02.rar 
-       # 3) zip all ver: .zip 
+        # Try to evaluate some safe things, for convenience
+        return self.coerceValue(section, key, value)
 
 
-       heads = []
+    # Convert a string to an int (any base)
+    def toInt(s):
+        return int(s, 0)
 
 
-       # Old RAR type, find all files ending in .rar
-       if is_oldrar (files):
-               regex = re.compile ('^.*\.rar$', re.IGNORECASE)
-               for f in files:
-                       if regex.match (f):
-                               heads.append (f)
+    # Mark it static
+    toInt = staticmethod(toInt)
 
 
-               return heads
+    # Convert a string to a bool
+    def toBool(s):
+        if s in ['t', 'T', 'True', 'true', 'yes', '1']:
+            return True
 
 
-       if is_newrar (files):
-               regex = re.compile ('^.*\.part01.rar$', re.IGNORECASE)
-               for f in files:
-                       if regex.match (f):
-                               heads.append (f)
+        if s in ['f', 'F', 'False', 'false', 'no', '0']:
+            return False
 
 
-               return heads
+        raise ValueError
 
 
-       if is_zip (files):
-               regex = re.compile ('^.*\.zip$', re.IGNORECASE)
-               for f in files:
-                       if regex.match (f):
-                               heads.append (f)
+    # Mark it static
+    toBool = staticmethod(toBool)
 
 
-               return heads
+################################################################################
 
 
-       # Not a type we know yet
-       raise ValueError
+# Global configuration, read from default configuration file
+config = RarslaveConfig()
 
 
+################################################################################
 
 
-def is_oldrar (files):
-       for f in files:
-               if has_extension (f, '.r00'):
-                       return True
+# A tiny class to hold logging output until we're finished
+class DelayedLogger (object):
 
 
-def is_newrar (files):
-       for f in files:
-               if has_extension (f, '.part01.rar'):
-                       return True
+    """A small class to hold logging output until the program is finished running.
+       It emulates sys.stdout in the needed ways for the logging module."""
 
 
-def is_zip (files):
-       for f in files:
-               if has_extension (f, '.zip'):
-                       return True
+    def __init__ (self, output=sys.stdout.write):
+        self.__messages = []
+        self.__output = output
 
 
+    def write (self, msg):
+        self.__messages.append (msg)
+
+    def flush (self):
+        pass
+
+    def size (self):
+        """Returns the number of messages queued for printing"""
+        return len (self.__messages)
+
+    def close (self):
+        """Print all messages, clear the queue"""
+        map(self.__output, self.__messages)
+        self.__messages = []
+
+################################################################################
+
+# Convert from the verbose command line option to the logging level that
+# will be used by the logging class to print messages
+def findLogLevel(options):
+
+    level = options.verbose - options.quiet
+
+    if level < -3:
+        level = -3
+
+    if level > 1:
+        level = 1
+
+    LEVELS = {
+         1 : logging.DEBUG,
+         0 : logging.INFO,
+        -1 : logging.WARNING,
+        -2 : logging.ERROR,
+        -3 : logging.CRITICAL
+    }
+
+    return LEVELS[level]
+
+################################################################################
+
+def parseCommandLineOptions():
+
+    # Build the OptionParser
+    parser = optparse.OptionParser()
+    parser.add_option('-n', '--not-recursive', dest='recursive', action='store_false',
+                        default=config.get('options', 'recursive'),
+                        help="Don't run recursively")
+
+    parser.add_option('-d', '--directory', dest='directory', type='string',
+                        default=config.get('directories', 'start'),
+                        help="Start working at DIR", metavar='DIR')
+
+    parser.add_option('-i', '--interactive', dest='interactive', action='store_true',
+                        default=config.get('options', 'interactive'),
+                        help="Confirm before removing files")
+
+    parser.add_option('--no-delete', dest='delete', action='store_false',
+                        default=config.get('options', 'delete'),
+                        help="Do not delete files used to repair")
+
+    parser.add_option('-q', '--quiet', dest='quiet', action='count',
+                        default=0, help="Output fatal messages only")
+
+    parser.add_option('-v', '--verbose', dest='verbose', action='count',
+                        default=config.get('options', 'verbosity'),
+                        help="Output extra information")
+
+    parser.add_option('-V', '--version', dest='version', action='store_true',
+                        default=False, help="Output version information")
+
+    parser.version = VERSION
+
+    # Parse the given options
+    (options, args) = parser.parse_args()
+
+    # Postprocess the options, basically sanitizing them
+    options.directory = PAR2Set.utils.absolutePath(options.directory)
+
+    # Make sure that the directory is valid
+    if not os.path.isdir (options.directory):
+        sys.stderr.write ('\"%s\" is not a valid directory. Use the \"-d\"\n' % options.directory)
+        sys.stderr.write ('option to override the working directory temporarily, or edit the\n')
+        sys.stderr.write ('configuration file to override the working directory permanently.\n')
+        sys.exit (1)
+
+    if options.version:
+        print PROGRAM + ' - ' + VERSION
+        print
+        print 'Copyright (c) 2005-2008 Ira W. Snyder (devel@irasnyder.com)'
+        print
+        print 'This program comes with ABSOLUTELY NO WARRANTY.'
+        print 'This is free software, and you are welcome to redistribute it'
+        print 'under certain conditions. See the file COPYING for details.'
+        sys.exit (0)
+
+    return (options, args)
+
+################################################################################
+
+# Find each unique CompareSet in the given directory and set of files
+def findUniqueSets(directory, files):
+
+    regex = r'^.*\.par2'
+    s = []
+
+    for f in PAR2Set.utils.findMatches(regex, files):
+
+        try:
+            c = PAR2Set.CompareSet(directory, f)
+        except:
+            # We just ignore any errors that happen, such as
+            # parsing the PAR file
+            pass
+        else:
+            # Ok, we got a valid set, add it to s
+            if c not in s:
+                s.append(c)
+
+    return s
+
+################################################################################
+
+# Run each PAR2Set type on a CompareSet
+def runEachType(cs, options):
+
+    types = (
+        PAR2Set.JoinProtected,
+        PAR2Set.Join,
+        PAR2Set.ZIP,
+        PAR2Set.OldRAR,
+        PAR2Set.NewRAR,
+        PAR2Set.ExtractFirstOldRAR,
+        PAR2Set.ExtractFirstNewRAR,
+        PAR2Set.NoExtract,
+    )
+
+    detected = False
+
+    # Try to detect each type in turn
+    for t in types:
+        try:
+            instance = t(cs, options)
+        except TypeError:
+            logging.debug('%s not detected for %s' % (t.__name__, cs.parityFile))
+            continue
+        else:
+            detected = True
+            logging.debug('%s detected for %s' % (t.__name__, cs.parityFile))
+
+        # We detected something, try to run it
+        try:
+            instance.run()
+        except (OSError, CalledProcessError):
+            logging.critical('Failure: %s' % instance)
+        else:
+            # Leave early, we're done
+            logging.info('Success: %s' % instance)
+            return
+
+    # Check that at least one detection worked
+    if not detected:
+        logging.critical('Detection failed: %s' % cs.parityFile)
+        logging.debug('The following information will help to create a detector')
+        logging.debug('===== BEGIN CompareSet RAW INFO =====')
+        logging.debug(str(cs))
+        logging.debug('===== END CompareSet RAW INFO =====')
+
+    # If we got here, either the detection didn't work or the run itself didn't
+    # work, so print out the message telling the user that we were unsuccessful
+    logging.critical('Unsuccessful: %s' % cs.parityFile)
+
+################################################################################
+
+def runDirectory(directory, files, options):
+
+    logging.debug('Running in directory: %s' % directory)
+    sets = findUniqueSets(directory, files)
+
+    for cs in sets:
+        try:
+            runEachType(cs, options)
+        except Exception, e:
+            import traceback
+            logging.error('Unknown Exception: %s' % cs.parityFile)
+            logging.error('===== BEGIN Bactrace =====')
+            [logging.error(l) for l in traceback.format_exc(e).split('\n')]
+            logging.error('===== END Bactrace =====')
+
+################################################################################
 
 def main ():
 
 def main ():
-       print find_all_par2_files ('/home/irasnyd/downloads/test_material/01/')
 
 
+    # Parse all of the command line options
+    (options, args) = parseCommandLineOptions()
+
+    # Set up the logger
+    logger = DelayedLogger()
+    logging.basicConfig(stream=logger, level=logging.WARNING, \
+                        format='%(levelname)-8s %(message)s')
+    logging.getLogger().setLevel (findLogLevel(options))
+
+    # Run recursively
+    if options.recursive:
+        for (directory, subDirectories, files) in os.walk(options.directory):
+            runDirectory(directory, files, options)
+
+    # Non-recursive
+    else:
+        directory = options.directory
+        files = os.listdir(directory)
+
+        runDirectory(directory, files, options)
+
+    # Print out all of the messages that have been accumulating
+    # in the DelayedLogger()
+    if logger.size() > 0:
+        print
+        print 'Log'
+        print '=' * 80
+        logger.close()
+
+# Check if we were called directly
 if __name__ == '__main__':
 if __name__ == '__main__':
-       main ()
+    main ()
+