Merge pull request #60 from sy-c/master

option string to constructor

Author: sy-c

CMakeLists.txt

@@ -105,6 +105,7 @@ add_library (objInfoLoggerClient OBJECT
   src/InfoLoggerClient.cxx
   src/infoLoggerMessageDecode.c
   src/InfoLoggerMessageHelper.cxx
+  src/infoLoggerUtils.cxx  
   src/utility.c
   src/simplelog.cxx
 )
@@ -249,6 +250,7 @@ add_executable(
   src/infoLoggerMessageDecode.c
   src/InfoLoggerMessageHelper.cxx
   src/InfoLoggerMessageList.cxx
+  src/infoLoggerUtils.cxx
   $<$<BOOL:${MYSQL_FOUND}>:src/InfoLoggerDispatchSQL.cxx>
 )
 target_include_directories(

include/InfoLogger/InfoLogger.hxx

@@ -139,6 +139,11 @@ class InfoLogger
   /// May throw exceptions on failure.
   InfoLogger();
 
+  // Constructor
+  // with optional options
+  // provided as a comma-separated list of key=value pairs
+  InfoLogger(const std::string& options);
+
   /// Destructor
   virtual ~InfoLogger();
 

src/InfoLogger.cxx

@@ -19,6 +19,7 @@
 
 #include "infoLoggerMessage.h"
 #include "InfoLoggerClient.h"
+#include "infoLoggerUtils.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -171,60 +172,105 @@ namespace AliceO2
 namespace InfoLogger
 {
 
-int infoLoggerDWarningDone = 0;
-
 // private class to isolate internal data from external interface
 class InfoLogger::Impl
 {
  public:
-  Impl()
+  Impl(const std::string& options)
   {
     // initiate internal members
     magicTag = InfoLoggerMagicNumber;
     numberOfMessages = 0;
     currentStreamMessage.clear();
     currentStreamOptions = undefinedMessageOption;
+    client = nullptr;
 
     floodReset();
 
     if (infoLog_proto_init()) {
       throw __LINE__;
     }
     refreshDefaultMsg();
-    currentMode = OutputMode::infoLoggerD;
-
-    const char* confEnv = getenv("INFOLOGGER_MODE");
-    if (confEnv != NULL) {
-      if (!strcmp(confEnv, "stdout")) {
-        currentMode = OutputMode::stdout;
-      } else if (!strcmp(confEnv, "infoLoggerD")) {
-        currentMode = OutputMode::infoLoggerD;
-      } else if (!strncmp(confEnv, "file", 4)) {
-        currentMode = OutputMode::file;
-        const char* logFile = "./log.txt";
-        if (confEnv[4] == ':') {
-          logFile = &confEnv[5];
+
+    // option-processing routine
+    auto processOptions = [&](std::string opt) {
+      std::map<std::string, std::string> kv;
+      if (getKeyValuePairsFromString(opt, kv)) {
+        throw __LINE__;
+      }
+      for (auto& it : kv) {
+        if (it.first == "outputMode") {
+          getOutputStreamFromString(it.second.c_str(), mainMode);
+        } else if (it.first == "outputModeFallback") {
+          getOutputStreamFromString(it.second.c_str(), fallbackMode);
+        } else if (it.first == "verbose") {
+          verbose = atoi(it.second.c_str());
+        } else {
+          // unknown option
+          // printf("Unknown option %s\n",it.second.c_str());
+          throw __LINE__;
         }
-        printf("Logging to file %s\n", logFile);
-        stdLog.setLogFile(logFile);
-      } else if (!strcmp(confEnv, "raw")) {
-        currentMode = OutputMode::raw;
-      } else if (!strcmp(confEnv, "none")) {
-        currentMode = OutputMode::none; // useful for benchmarks
       }
+      return;
+    };
+
+    // parse options from constructor arg
+    processOptions(options);
+
+    // parse options from environment
+    const char* confEnvOptions = getenv("INFOLOGGER_OPTIONS");
+    if (confEnvOptions != NULL) {
+      processOptions(confEnvOptions);
     }
-    client = nullptr;
-    if (currentMode == OutputMode::infoLoggerD) {
-      client = new InfoLoggerClient;
-      if ((client == nullptr) || (!client->isOk())) {
-        // fallback to stdout if infoLoggerD not available
-        if (!infoLoggerDWarningDone) {
-          infoLoggerDWarningDone = 1;
-          //fprintf(stderr,"infoLoggerD not available, falling back to stdout logging\n");
+
+    const char* confEnvMode = getenv("INFOLOGGER_MODE");
+    if (confEnvMode != NULL) {
+      getOutputStreamFromString(confEnvMode, mainMode);
+    }
+
+    // init main output and fallbacks if needed
+    currentMode = mainMode;
+    for (int it = 0; it < 3; it++) {
+      if (it == 0) {
+        currentMode = mainMode;
+      } else if (it == 1) {
+        currentMode = fallbackMode;
+      } else {
+        currentMode.mode = OutputMode::none;
+        currentMode.path = "/dev/null";
+      }
+      if (verbose) {
+        printf("Using output mode %s\n", getStringFromMode(currentMode.mode));
+      }
+
+      if (currentMode.mode == OutputMode::file) {
+        if (verbose) {
+          printf("Logging to file %s\n", currentMode.path.c_str());
+        }
+        if (stdLog.setLogFile(currentMode.path.c_str(), 0, 4, 0) == 0) {
+          break;
+        }
+      } else if (currentMode.mode == OutputMode::stdout) {
+        if (stdLog.setLogFile(nullptr) == 0) {
+          break;
+        }
+      } else if (currentMode.mode == OutputMode::none) {
+        if (stdLog.setLogFile(currentMode.path.c_str()) == 0) {
+          break;
+        }
+      } else if (currentMode.mode == OutputMode::infoLoggerD) {
+        client = new InfoLoggerClient;
+        if (client != nullptr) {
+          if (client->isOk()) {
+            break;
+          }
         }
-        currentMode = OutputMode::stdout;
+      }
+      if (verbose) {
+        printf("Output to %s failed\n", getStringFromMode(currentMode.mode));
       }
     }
+
     // todo
     // switch mode based on configuration / environment
     // connect to client only on first message (or try again after timeout)
@@ -258,7 +304,61 @@ class InfoLogger::Impl
                     raw,
                     none };
 
-  OutputMode currentMode; // current option for output
+  struct OutputStream {
+    OutputMode mode;  // selected mode
+    std::string path; // optional path (eg for 'file' mode)
+  };
+
+  // convert a string to a member of the OutputMode enum
+  // and sets filePath in case of the "file" mode
+  // throw an integer error code on error
+  void getOutputStreamFromString(const char* s, OutputStream& out)
+  {
+    if (s == nullptr) {
+      throw __LINE__;
+    }
+    out.mode = OutputMode::none;
+    out.path = "";
+    if (!strcmp(s, "stdout")) {
+      out.mode = OutputMode::stdout;
+    } else if (!strncmp(s, "file", 4)) {
+      out.mode = OutputMode::file;
+      if (s[4] == ':') {
+        out.path = std::string(&s[5]);
+      } else {
+        out.path = "./log.txt";
+      }
+    } else if (!strcmp(s, "infoLoggerD")) {
+      out.mode = OutputMode::infoLoggerD;
+    } else if (!strcmp(s, "raw")) {
+      out.mode = OutputMode::raw;
+    } else if (!strcmp(s, "none")) {
+      out.mode = OutputMode::none;
+    } else {
+      throw __LINE__;
+    }
+    return;
+  };
+
+  const char* getStringFromMode(OutputMode m)
+  {
+    if (m == OutputMode::stdout) {
+      return "stdout";
+    } else if (m == OutputMode::file) {
+      return "file";
+    } else if (m == OutputMode::infoLoggerD) {
+      return "infoLoggerD";
+    } else if (m == OutputMode::none) {
+      return "none";
+    }
+    return "unknown";
+  }
+
+  OutputStream currentMode;                                // current option for output
+  OutputStream mainMode = { OutputMode::infoLoggerD, "" }; // main output mode
+  OutputStream fallbackMode = { OutputMode::stdout, "" };  // in case main mode is not available
+
+  bool verbose = 0; // in verbose mode, more info printed on stdout
 
   /// Log a message, with a list of arguments of type va_list.
   /// \param message  NUL-terminated string message to push to the log system. It uses the same format as specified for printf(), and the function accepts additionnal formatting parameters.
@@ -285,7 +385,7 @@ class InfoLogger::Impl
   void refreshDefaultMsg();
   infoLog_msg_t defaultMsg; //< default log message (in particular, to complete optionnal fields)
 
-  InfoLoggerClient* client; //< entity to communicate with local infoLoggerD
+  InfoLoggerClient* client = nullptr; //< entity to communicate with local infoLoggerD
   SimpleLog stdLog;         //< object to output messages to stdout/file
 
   bool isRedirecting = false;                  // state of stdout/stderr redirection
@@ -561,7 +661,7 @@ int InfoLogger::Impl::pushMessage(const InfoLoggerMessageOption& options, const
     // on error, close connection / use stdout / buffer messages in memory ?
   }
 
-  if ((currentMode == OutputMode::stdout) || (currentMode == OutputMode::file)) {
+  if ((currentMode.mode == OutputMode::stdout) || (currentMode.mode == OutputMode::file)) {
     char buffer[LOG_MAX_SIZE];
     msgHelper.MessageToText(&msg, buffer, sizeof(buffer), InfoLoggerMessageHelper::Format::Simple);
 
@@ -582,7 +682,7 @@ int InfoLogger::Impl::pushMessage(const InfoLoggerMessageOption& options, const
   }
 
   // raw output: infoLogger protocol to stdout
-  if (currentMode == OutputMode::raw) {
+  if (currentMode.mode == OutputMode::raw) {
     char buffer[LOG_MAX_SIZE];
     msgHelper.MessageToText(&msg, buffer, sizeof(buffer), InfoLoggerMessageHelper::Format::Encoded);
     puts(buffer);
@@ -625,7 +725,15 @@ int InfoLogger::Impl::logV(const InfoLoggerMessageOption& options, const InfoLog
 
 InfoLogger::InfoLogger()
 {
-  mPimpl = std::make_unique<InfoLogger::Impl>();
+  mPimpl = std::make_unique<InfoLogger::Impl>("");
+  if (mPimpl == NULL) {
+    throw __LINE__;
+  }
+}
+
+InfoLogger::InfoLogger(const std::string& options)
+{
+  mPimpl = std::make_unique<InfoLogger::Impl>(options);
   if (mPimpl == NULL) {
     throw __LINE__;
   }

src/InfoLoggerScripting.cxx

@@ -22,6 +22,10 @@ InfoLogger::InfoLogger()
 {
   logHandle = std::make_unique<baseInfoClass>();
 }
+InfoLogger::InfoLogger(const std::string& options)
+{
+  logHandle = std::make_unique<baseInfoClass>(options);
+}
 
 InfoLogger::~InfoLogger()
 {

src/InfoLoggerScripting.hxx

@@ -76,6 +76,7 @@ class InfoLogger
 {
  public:
   InfoLogger();
+  InfoLogger(const std::string& options);
   ~InfoLogger();
 
   // log with default metadata fields and specified severity

src/infoLogger.i

@@ -45,6 +45,7 @@ class InfoLoggerMetadata {
 class InfoLogger {
   public:
     InfoLogger();
+    InfoLogger(const std::string &message);
     ~InfoLogger();
 
     int logInfo(const std::string &message);

src/infoLoggerUtils.cxx

@@ -0,0 +1,53 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "infoLoggerUtils.h"
+
+int getKeyValuePairsFromString(const std::string& input, std::map<std::string, std::string>& output)
+{
+  output.clear();
+  std::size_t ix0 = 0;                 // begin of pair in string
+  std::size_t ix1 = std::string::npos; // end of pair in string
+  std::size_t ix2 = std::string::npos; // position of '='
+  for (;;) {
+    ix1 = input.find(",", ix0);
+    ix2 = input.find("=", ix0);
+    if (ix2 >= ix1) {
+      break;
+    } // end of string
+
+    const std::string& trimchars = "\t\n\v\f\r ";
+
+    // trim key
+    std::string key = input.substr(ix0, ix2 - ix0);
+    key.erase(key.find_last_not_of(trimchars) + 1);
+    key.erase(0, key.find_first_not_of(trimchars));
+
+    // trim value
+    std::string value;
+    if (ix1 == std::string::npos) {
+      value = input.substr(ix2 + 1);
+    } else {
+      value = input.substr(ix2 + 1, ix1 - (ix2 + 1));
+    }
+    value.erase(value.find_last_not_of(trimchars) + 1);
+    value.erase(0, value.find_first_not_of(trimchars));
+
+    // insert in map
+    output.insert(std::pair<std::string, std::string>(key, value));
+
+    // iterate next pair unless end of string
+    if (ix1 == std::string::npos) {
+      break;
+    }
+    ix0 = ix1 + 1;
+  }
+  return 0;
+}

src/infoLoggerUtils.h

@@ -0,0 +1,15 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <string>
+#include <map>
+
+// convert a string comma-separated list of key=value pairs to a map
+int getKeyValuePairsFromString(const std::string& input, std::map<std::string, std::string>& output);

test/testInfoLoggerDB.cxx

@@ -5,6 +5,10 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#if LIBMYSQL_VERSION_ID >= 80000
+typedef bool my_bool;
+#endif
+
 int main(int argc, char** argv)
 {