[GNUnet-SVN] [taler-taler-util] 17/51: 4453.

[gnunet]

This is an automated email from the git hooks/post-receive script.

ng0 pushed a commit to branch master
in repository taler-util.

commit 7167718b6aa923eef4d333fea7a87ea68ce51351
Author: Marcello Stanisci <address@hidden>
AuthorDate: Tue Feb 5 22:23:41 2019 +0100

    4453.
    
    Implementing the GNUNET_LOG and GNUNET_FORCE_LOG
    logic.  NOTE: the code is not tested!
---
 python/log/gnunet_log.py | 71 ++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 65 insertions(+), 6 deletions(-)

diff --git a/python/log/gnunet_log.py b/python/log/gnunet_log.py
index ee2dc12..dcce72f 100755
--- a/python/log/gnunet_log.py
+++ b/python/log/gnunet_log.py
@@ -15,6 +15,12 @@ class GnunetLogLevel:
     def __str__(self):
         return self.stringification
 
+class LogDefinition:
+    
+    def __init__(self, component, forced, loglevel):
+        self.component = component
+        self.forced = forced
+        self.loglevel = loglevel
 
 class GnunetLogger:
     
@@ -28,19 +34,57 @@ class GnunetLogger:
                  "INFO": INFO,
                  "DEBUG": DEBUG}
 
-    def __init__(self, component, loglevel):
+    def __init__(self, component, loglevel=None):
         print("Log setup, component: %s, level: %s" % (component, 
str(loglevel)))
         self.component = component
-        # loglevel set at "compile time".
         self.loglevel = loglevel
-        logging.basicConfig(level=loglevel.getNativeLevel())
+        # just because it _needs_ to be set in the beginning.
+        logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(component)
+        self.no_forced_definitions = True
+
+        if os.environ.get("GNUNET_LOG"):
+            parse_definitions(os.environ.get("GNUNET_LOG", False))
+
+        if os.environ.get("GNUNET_FORCE_LOG"):
+            self.no_forced_definitions = False
+            parse_definitions(os.environ.get("GNUNET_LOG", True))
 
     def __internal_log(self, message, message_loglevel, ruling_loglevel):
 
-        if not ruling_loglevel:
-            print("Garbage loglevel fetched from env, not logging")
-        self.logger.setLevel(level=ruling_loglevel.getNativeLevel())
+        # Ordinary case (level setup + nothing forced).
+        if ruling_loglevel and self.no_forced_definitions:
+            self.logger.setLevel(level=ruling_loglevel.getNativeLevel())
+
+        # We crawl through GNUNET_FORCE_LOG definitions,
+        # or GNUNET_LOG (in case of non-forced definition
+        # and non-given loglevel at object creation time)
+        for defi in self.definitions:
+            if defi.forced or not self.loglevel:
+                # Temporarily checking only the component name.
+                # To be extended with all the others definition-parts.
+                if self.component == defi.component:
+                    self.logger.setLevel(level=defi.loglevel)
+
+        #
+        # If the flow got here, then one of the following
+        # may hold.
+        #
+        # (1) GNUNET_FORCE_LOG was given and no definition was
+        #     found for this component (neither forced nor unforced).
+        #     Possibly, there also exists a default loglevel.
+        
+        if self.loglevel:
+            self.logger.setLevel(level=self.loglevel)
+
+
+        #
+        # (2) GNUNET_FORCE_LOG was NOT given and neither was
+        #     a default loglevel, and also a unforced definition
+        #     wasn't found.  Must assign a made-up loglevel.
+        #
+        
+        self.logger.setLevel(level=logging.INFO)
 
         if GnunetLogger.ERROR == message_loglevel:
             fn = self.logger.error
@@ -50,8 +94,23 @@ class GnunetLogger:
             fn = self.logger.info
         if GnunetLogger.DEBUG == message_loglevel:
             fn = self.logger.debug
+
         fn(message)
 
+    def parse_definitions(data, forced):
+        gfl_split = gfl.split("/")
+        for component in gfl_split:
+            gfl_split_split = component.split(";")
+
+            if 5 != len(gfl_split_split):
+                print("warning: GNUNET_(FORCE_)LOG is malformed")
+                return
+
+            definition = LogDefinition(gfl_split_split[0],
+                                       forced,
+                                       loglevel=glf_split_split[4])
+            self.definitions.push(definition)
+
     def log(self, message, loglevel):
         if not os.environ.get("GNUNET_FORCE_LOG"):
             self.__internal_log(message, loglevel, self.loglevel)

-- 
To stop receiving notification emails like this one, please contact
address@hidden.