import re
import os
+import logging
# This is a fairly generic class which does all of the major things that a PAR2
# set will need to have done to be verified and extracted. For most "normal" types
# check the result
if ret != 0:
- fatalMessage ('PAR2 Check / Repair failed: %s' % self.p2file)
+ logging.critical ('PAR2 Check / Repair failed: %s' % self.p2file)
return -ECHECK
return SUCCESS
for f in files:
try:
os.remove (os.path.join (dir, f))
- debugMessage ('Deleteing: %s' % os.path.join (dir, f))
+ logging.debug ('Deleteing: %s' % os.path.join (dir, f))
except:
- fatalMessage ('Failed to delete: %s' % os.path.join (dir, f))
+ logging.error ('Failed to delete: %s' % os.path.join (dir, f))
return -EDELETE
return SUCCESS
ret = self.runVerifyAndRepair ()
if ret != SUCCESS:
- fatalMessage ('Repair stage failed for: %s' % self.p2file)
+ logging.critical ('Repair stage failed for: %s' % self.p2file)
return -ECHECK
self.update_matches ()
ret = self.runExtract ()
if ret != SUCCESS:
- fatalMessage ('Extraction stage failed for: %s' % self.p2file)
+ logging.critical ('Extraction stage failed for: %s' % self.p2file)
return -EEXTRACT
self.update_matches ()
ret = self.runDelete ()
if ret != SUCCESS:
- fatalMessage ('Deletion stage failed for: %s' % self.p2file)
+ logging.critical ('Deletion stage failed for: %s' % self.p2file)
return -EDELETE
- normalMessage ('Successfully completed: %s' % self.p2file)
+ logging.info ('Successfully completed: %s' % self.p2file)
return SUCCESS
def safe_create_directory (self, dir):
try:
os.makedirs (dir)
- verboseMessage ('Created directory: %s' % dir)
+ logging.info ('Created directory: %s' % dir)
except OSError:
- fatalMessage ('FAILED to create directory: %s' % dir)
+ logging.critical ('FAILED to create directory: %s' % dir)
return -ECREATE
return SUCCESS
for h in self.find_extraction_heads ():
full_head = full_abspath (os.path.join (self.dir, h))
ret = self.extraction_function (full_head, todir)
- debugMessage ('Extraction Function returned: %d' % ret)
+ logging.debug ('Extraction Function returned: %d' % ret)
# Check error code
if ret != SUCCESS:
- fatalMessage ('Failed extracting: %s' % h)
+ logging.critical ('Failed extracting: %s' % h)
return -EEXTRACT
return SUCCESS
#!/usr/bin/env python
# vim: set ts=4 sts=4 sw=4 textwidth=92:
+import logging
import PAR2Set
from RarslaveCommon import *
ret = self.runExtract ()
if ret != SUCCESS:
- fatalMessage ('Extraction stage failed for: %s' % self.p2file)
+ logging.critical ('Extraction stage failed for: %s' % self.p2file)
return -EEXTRACT
self.update_matches ()
ret = self.runVerifyAndRepair ()
if ret != SUCCESS:
- fatalMessage ('Repair stage failed for: %s' % self.p2file)
+ logging.critical ('Repair stage failed for: %s' % self.p2file)
return -ECHECK
self.update_matches ()
ret = self.runDelete ()
if ret != SUCCESS:
- fatalMessage ('Deletion stage failed for: %s' % self.p2file)
+ logging.critical ('Deletion stage failed for: %s' % self.p2file)
return -EDELETE
- normalMessage ('Successfully completed: %s' % self.p2file)
+ logging.info ('Successfully completed: %s' % self.p2file)
return SUCCESS
#!/usr/bin/env python
# vim: set ts=4 sts=4 sw=4 textwidth=92:
+import logging
import PAR2Set
from RarslaveCommon import *
# check the result
if ret != 0:
- fatalMessage ('PAR2 Check / Repair failed: %s' % self.p2file)
+ logging.critical ('PAR2 Check / Repair failed: %s' % self.p2file)
return -ECHECK
return SUCCESS
import os
import re
+import logging
import RarslaveGlobals
-import RarslaveLogger
import Par2Parser
# Global constants
files = Par2Parser.get_protected_files (dir, f)
done = True
except (EnvironmentError, OSError, OverflowError):
- verboseMessage ('Corrupt PAR2 file: %s' % f)
+ logging.warning ('Corrupt PAR2 file: %s' % f)
# Now that we're out of the loop, check if we really finished
if not done:
- fatalMessage ('All PAR2 files corrupt for: %s' % p2head)
+ logging.critical ('All PAR2 files corrupt for: %s' % p2head)
# Return whatever we've got, empty or not
return files
return True
-# Convience functions for the logger
-
-def fatalMessage (msg):
- RarslaveGlobals.logger.addMessage (msg, RarslaveLogger.MessageType.Fatal)
-
-def normalMessage (msg):
- RarslaveGlobals.logger.addMessage (msg, RarslaveLogger.MessageType.Normal)
-
-def verboseMessage (msg):
- RarslaveGlobals.logger.addMessage (msg, RarslaveLogger.MessageType.Verbose)
-
-def debugMessage (msg):
- RarslaveGlobals.logger.addMessage (msg, RarslaveLogger.MessageType.Debug)
-
# Convience functions for the config
def config_get_value (section, name):
import PAR2Set_EF_OLDRAR
import PAR2Set_EF_NEWRAR
+import logging
+
class RarslaveDetector (object):
# A tuple of tuples with the following definition:
p2set = classname (self.dir, self.p2file)
detected = True
- debugMessage ('Detected type: %s' % p2set)
+ logging.debug ('Detected type: %s' % p2set)
# Try to have rarslave do it's thing
ret = p2set.runAll ()
if ret == SUCCESS:
break
else:
- fatalMessage ('Detected type failed for: %s' % self.p2file)
+ logging.error ('Detected type failed for: %s' % self.p2file)
# Make sure we detected at least one valid type
if not detected:
- fatalMessage ('Unable to determine type: %s' % self.p2file)
- verboseMessage ('The following information will help in writing a detector:')
- verboseMessage ('name_matches: %s' % self.name_matched_files)
- verboseMessage ('prot_matches: %s' % self.prot_matched_files)
+ logging.warning ('Unable to determine type: %s' % self.p2file)
+ logging.debug ('The following information will help in writing a detector:')
+ logging.debug ('name_matches: %s' % self.name_matched_files)
+ logging.debug ('prot_matches: %s' % self.prot_matched_files)
return -EDETECT
# Make sure that something worked
if ret != SUCCESS:
- fatalMessage ('All types failed for: %s' % self.p2file)
+ logging.critical ('All types failed for: %s' % self.p2file)
return ret
+++ /dev/null
-#!/usr/bin/env python
-# vim: set ts=4 sts=4 sw=4 textwidth=92:
-
-class MessageType (object):
- Fatal = -1
- Normal = 0
- Verbose = 1
- Debug = 2
-
-class RarslaveMessage (object):
-
- # Instance Variables:
- # ==========================================================================
- # msg -- The message to be printed
- # type -- The type of message (Fatal, Normal, Verbose, or Debug)
-
- def __init__ (self, msg, type=MessageType.Normal):
- self.msg = msg
- self.type = type
-
- def __repr__ (self):
- return "%s" % self.msg
-
- def isFatal (self):
- return self.type == MessageType.Fatal
-
- def isNormal (self):
- return self.type == MessageType.Normal
-
- def isVerbose (self):
- return self.type == MessageType.Verbose
-
- def isDebug (self):
- return self.type == MessageType.Debug
-
-class RarslaveLogger (object):
- # This class will log multiple messages, one for each set that is operated on.
- # It will then be able to print all of them out.
-
- # Instance Variables:
- # ==========================================================================
- # __messages -- The list of RarslaveMessage()s to be printed later.
-
- def __init__ (self):
- self.__messages = []
-
- def addMessage (self, msg, type=MessageType.Normal):
- self.__messages.append (RarslaveMessage (msg, type))
-
- def hasFatalMessages (self):
- for m in self.__messages:
- if m.isFatal ():
- return True
-
- return False
-
- def hasNormalMessages (self):
- for m in self.__messages:
- if m.isNormal ():
- return True
-
- return False
-
- def hasVerboseMessages (self):
- for m in self.__messages:
- if m.isVerbose ():
- return True
-
- return False
-
- def hasDebugMessages (self):
- for m in self.__messages:
- if m.isDebug ():
- return True
-
- return False
-
- def printAllMessages (self, level=MessageType.Normal):
- # Print all messages with level upto and including $level.
- for m in self.__messages:
- if m.type <= level:
- print m
-
- def printLoglevel (self, level=MessageType.Normal):
- # Print all message with exactly the loglevel given
- for m in self.__messages:
- if m.type == level:
- print m
-
-def main ():
- pass
-
-if __name__ == '__main__':
- main ()
-
VERSION="2.0.0"
PROGRAM="rarslave2"
-import os, sys, optparse
-import RarslaveLogger
+import os, sys, optparse, logging
import RarslaveDetector
import RarslaveGlobals
from RarslaveCommon import *
# Global options from the RarslaveGlobals class
options = RarslaveGlobals.options
config = RarslaveGlobals.config
-logger = RarslaveGlobals.logger
+
+# A tiny class to hold logging output until we're finished
+class DelayedLogger (object):
+ 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"""
+ for m in self.__messages:
+ self.__output (m)
+
+ self.__messages = []
# A tiny class used to find unique PAR2 sets
class CompareSet (object):
loglevel = options.verbose - options.quiet
- if loglevel < RarslaveLogger.MessageType.Fatal:
- loglevel = RarslaveLogger.MessageType.Fatal
-
- if loglevel > RarslaveLogger.MessageType.Debug:
- loglevel = RarslaveLogger.MessageType.Debug
-
- return loglevel
+ if loglevel > 1:
+ loglevel = 1
-def printMessageTable (loglevel):
+ if loglevel < -3:
+ loglevel = -3
- if logger.hasFatalMessages ():
- print '\nFatal Messages\n' + '=' * 80
- logger.printLoglevel (RarslaveLogger.MessageType.Fatal)
+ LEVELS = { 1 : logging.DEBUG,
+ 0 : logging.INFO,
+ -1: logging.WARNING,
+ -2: logging.ERROR,
+ -3: logging.CRITICAL
+ }
- if loglevel == RarslaveLogger.MessageType.Fatal:
- return
-
- if logger.hasNormalMessages ():
- print '\nNormal Messages\n' + '=' * 80
- logger.printLoglevel (RarslaveLogger.MessageType.Normal)
-
- if loglevel == RarslaveLogger.MessageType.Normal:
- return
-
- if logger.hasVerboseMessages ():
- print '\nVerbose Messages\n' + '=' * 80
- logger.printLoglevel (RarslaveLogger.MessageType.Verbose)
-
- if loglevel == RarslaveLogger.MessageType.Verbose:
- return
-
- if logger.hasDebugMessages ():
- print '\nDebug Messages\n' + '=' * 80
- logger.printLoglevel (RarslaveLogger.MessageType.Debug)
-
- return
+ return LEVELS [loglevel]
def main ():
+ # Setup the logger
+ logger = DelayedLogger ()
+ logging.basicConfig (stream=logger, level=logging.WARNING, \
+ format='%(levelname)-8s %(message)s')
+
# Build the OptionParser
parser = optparse.OptionParser()
parser.add_option('-n', '--not-recursive',
run_options (options)
# Find the loglevel using the options given
- loglevel = find_loglevel (options)
+ logging.getLogger().setLevel (find_loglevel (options))
# Run recursively
if options.recursive:
ret = detector.runMatchingTypes ()
# Print the results
- printMessageTable (loglevel)
+ if logger.size () > 0:
+ print 'Log\n' + '=' * 80
+ logger.close ()
# Done!
return 0
projects / rarslave2.git / commitdiff