[LOGGER] Change inner workings (again)

Change the inner workings of the RarslaveLogger class so that it has
four different message types: Fatal, Normal, Verbose, Debug. This also
adds the function printLoglevel() to the RarslaveLogger class. It will
print all messages at a certain loglevel.

Also update the unit tests so that they behave with the current workings of
the RarslaveLogger class.

Signed-off-by: Ira W. Snyder <devel@irasnyder.com>

diff --git a/RarslaveLogger.py b/RarslaveLogger.py
index 06b59a6..d60b105 100644 (file)
--- a/RarslaveLogger.py
+++ b/RarslaveLogger.py
@@ -1,18 +1,31 @@
 #!/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):
-       def __init__ (self, msg, printquiet):
+       def __init__ (self, msg, type=MessageType.Normal):
                self.msg = msg
-               self.printquiet = printquiet
+               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):
-               # A message is verbose only if we should
-               # print it when we are not printing quietly
-               return not self.printquiet
+               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.
@@ -21,20 +34,48 @@ class RarslaveLogger (object):
        def __init__ (self):
                self.__messages = []
 
-       def addMessage (self, msg, printquiet=True):
-               # Add a message to the dictionary, to be printed later.
-               # The printquiet variable controls whether the message will be printed
-               # normally, or only in verbose mode. The default is to print always.
+       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
 
-               self.__messages.append (RarslaveMessage (msg, printquiet))
+               return False
 
-       def printAllMessages (self, verbose=False):
-               for msg in self.__messages:
-                       # Skip verbose messages if we're not in verbose mode
-                       if msg.isVerbose() and not verbose:
-                               continue
+       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
 
-                       print msg
+       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

diff --git a/rarslave-test.py b/rarslave-test.py
index 389dcf2..f82fc12 100644 (file)
--- a/rarslave-test.py
+++ b/rarslave-test.py
@@ -3,8 +3,7 @@
 
 import os, sys, unittest
 from rarslave import *
-from RarslaveLogger import RarslaveLogger
-from RarslaveLogger import RarslaveMessage
+from RarslaveLogger import RarslaveLogger,RarslaveMessage,MessageType
 
 class rarslavetest (unittest.TestCase):
 
@@ -99,19 +98,20 @@ class rarslavetest (unittest.TestCase):
                STR1 = "Hello World"
                STR2 = "Goodbye, \nCruel World"
 
-               self.assertEquals (STR1, RarslaveMessage (STR1, True ).__repr__())
-               self.assertEquals (STR1, RarslaveMessage (STR1, False).__repr__())
-               self.assertEquals (STR2, RarslaveMessage (STR2, True ).__repr__())
-               self.assertEquals (STR2, RarslaveMessage (STR2, False).__repr__())
+               self.assertEquals (STR1, RarslaveMessage (STR1).__repr__())
+               self.assertEquals (STR1, RarslaveMessage (STR1, MessageType.Normal).__repr__())
+               self.assertEquals (STR2, RarslaveMessage (STR2, MessageType.Verbose).__repr__())
+               self.assertEquals (STR2, RarslaveMessage (STR2, MessageType.Debug).__repr__())
 
        def testisVerboseMessage (self):
                STR1 = "Hello World"
                STR2 = "Goodbye, \nCruel World"
 
-               self.assertTrue (RarslaveMessage (STR1, False).isVerbose())
-               self.assertTrue (RarslaveMessage (STR2, False).isVerbose())
-               self.assertFalse (RarslaveMessage (STR1, True).isVerbose())
-               self.assertFalse (RarslaveMessage (STR2, True).isVerbose())
+               self.assertTrue (RarslaveMessage (STR1, MessageType.Verbose).isVerbose())
+               self.assertTrue (RarslaveMessage (STR2, MessageType.Verbose).isVerbose())
+               self.assertFalse (RarslaveMessage (STR1).isVerbose())
+               self.assertFalse (RarslaveMessage (STR2, MessageType.Debug).isVerbose())
+               self.assertFalse (RarslaveMessage (STR2, MessageType.Normal).isVerbose())
 
 
 if __name__ == '__main__':

diff --git a/rarslave.py b/rarslave.py
index 224d105..4e6db42 100644 (file)
--- a/rarslave.py
+++ b/rarslave.py
@@ -4,13 +4,13 @@
 import re, os, sys
 import par2parser
 import RarslaveConfig
-from RarslaveLogger import RarslaveLogger
+import RarslaveLogger
 
 # Global Variables
 (TYPE_OLDRAR, TYPE_NEWRAR, TYPE_ZIP, TYPE_NOEXTRACT) = range (4)
 (SUCCESS, ECHECK, EEXTRACT, EDELETE) = range(4)
 config = RarslaveConfig.RarslaveConfig()
-logger = RarslaveLogger ()
+logger = RarslaveLogger.RarslaveLogger ()
 
 class RarslaveExtractor (object):
 
@@ -32,11 +32,11 @@ class RarslaveExtractor (object):
 
                # Create the directory $todir if it doesn't exist
                if todir != None and not os.path.isdir (todir):
-                       logger.addMessage ('Creating directory: %s' % todir, False)
+                       logger.addMessage ('Creating directory: %s' % todir, RarslaveLogger.MessageType.Verbose)
                        try:
                                os.makedirs (todir)
                        except OSError:
-                               logger.addMessage ('FAILED to create directory: %s' % todir)
+                               logger.addMessage ('FAILED to create directory: %s' % todir, RarslaveLogger.MessageType.Fatal)
                                return -EEXTRACT
 
                # Extract all heads
@@ -56,7 +56,7 @@ class RarslaveExtractor (object):
 
                        # Check error code
                        if ret != SUCCESS:
-                               logger.addMessage ('Failed extracting: %s' % h)
+                               logger.addMessage ('Failed extracting: %s' % h, RarslaveLogger.MessageType.Fatal)
                                return -EEXTRACT
 
                return SUCCESS
@@ -144,7 +144,7 @@ class RarslaveRepairer (object):
 
                # check the result
                if ret != 0:
-                       logger.addMessage ('PAR2 Check / Repair failed: %s' % self.file)
+                       logger.addMessage ('PAR2 Check / Repair failed: %s' % self.file, RarslaveLogger.MessageType.Fatal)
                        return -ECHECK
 
                return SUCCESS
@@ -287,11 +287,12 @@ def find_extraction_heads (dir, files):
                        for f in prot_files:
                                extractor.addHead (dir, f)
                else:
-                       logger.addMessage ('Error parsing all PAR2 files in this set ...', True)
+                       logger.addMessage ('Error parsing all PAR2 files in this set ...')
 
        # Make sure we found the type
        if extractor == None:
-               logger.addMessage ('Not able to find an extractor for this type of set: %s' % p2files[0])
+               logger.addMessage ('Not able to find an extractor for this type of set: %s' % p2files[0],
+                               RarslaveLogger.MessageType.Fatal)
 
                # No-heads here, but it's better than failing completely
                extractor = RarslaveExtractor (TYPE_NOEXTRACT)
@@ -381,7 +382,7 @@ class PAR2Set (object):
                ret = repairer.checkAndRepair ()
 
                if ret != SUCCESS:
-                       logger.addMessage ('Repair stage failed for: %s' % par2head)
+                       logger.addMessage ('Repair stage failed for: %s' % par2head, RarslaveLogger.MessageType.Fatal)
                        return -ECHECK
 
                # Extraction Stage
@@ -390,7 +391,7 @@ class PAR2Set (object):
                ret = extractor.extract (EXTRACT_DIR)
 
                if ret != SUCCESS:
-                       logger.addMessage ('Extraction stage failed for: %s' % par2head)
+                       logger.addMessage ('Extraction stage failed for: %s' % par2head, RarslaveLogger.MessageType.Fatal)
                        return -EEXTRACT
 
                # Deletion Stage
@@ -399,10 +400,10 @@ class PAR2Set (object):
                ret = delete_list (deleteable_files, DELETE_INTERACTIVE)
 
                if ret != SUCCESS:
-                       logger.addMessage ('Deletion stage failed for: %s' % par2head)
+                       logger.addMessage ('Deletion stage failed for: %s' % par2head, RarslaveLogger.MessageType.Fatal)
                        return -EDELETE
 
-               logger.addMessage ('Successfully completed: %s' % par2head, True)
+               logger.addMessage ('Successfully completed: %s' % par2head)
                return SUCCESS
 
 def delete_list (files, interactive=False):
@@ -455,7 +456,26 @@ def main ():
                        p.run_all ()
 
        print '\nRARSLAVE STATUS\n'
+
+       if logger.hasFatalMessages ():
+               print '\nFatal Messages\n' + '=' * 80
+               logger.printLoglevel (RarslaveLogger.MessageType.Fatal)
+
+       if logger.hasNormalMessages ():
+               print '\nNormal Messages\n' + '=' * 80
+               logger.printLoglevel (RarslaveLogger.MessageType.Normal)
+
+       if logger.hasVerboseMessages ():
+               print '\nVerbose Messages\n' + '=' * 80
+               logger.printLoglevel (RarslaveLogger.MessageType.Verbose)
+
+       if logger.hasDebugMessages ():
+               print '\nDebug Messages\n' + '=' * 80
+               logger.printLoglevel (RarslaveLogger.MessageType.Debug)
+
+       print '\n\nALL MESSAGES:'
        logger.printAllMessages ()
 
 if __name__ == '__main__':
        main ()
+