Replaced log::Param params[] with std::list<log::Param>

common/Configuration.cpp

@@ -113,7 +113,7 @@ const std::string& cta::common::Configuration::getConfEntString(
         // release the lock
         pthread_rwlock_unlock(&m_lock);
         if(NULL != log) {           
-          log::Param params[] = {   
+          std::list<log::Param> params = {   
             log::Param("category", category),
             log::Param("key", key),
             log::Param("value", entIt->second),
@@ -125,7 +125,7 @@ const std::string& cta::common::Configuration::getConfEntString(
     }
     // no entry found
     if(NULL != log) {
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("category", category),
         log::Param("key", key),
         log::Param("value", defaultValue),
@@ -139,7 +139,7 @@ const std::string& cta::common::Configuration::getConfEntString(
     pthread_rwlock_unlock(&m_lock);
     // log the exception
     if(NULL != log) {
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("category", category),
         log::Param("key", key),
         log::Param("value", defaultValue),
@@ -191,7 +191,7 @@ const std::string& cta::common::Configuration::getConfEntString(
     }
 
     if(NULL != log) {
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("category", category),
         log::Param("key", key),
         log::Param("value", entIt->second),

common/Configuration.hpp

@@ -132,7 +132,7 @@ namespace cta { namespace common {
           strValue = getConfEntString(category, key);
         } catch(cta::exception::Exception &ex) {
           if(NULL != log) {
-            log::Param params[] = {
+            std::list<log::Param> params = {
               log::Param("category", category),
               log::Param("key", key),
               log::Param("value", defaultValue),
@@ -157,7 +157,7 @@ namespace cta { namespace common {
         ss >> value;
 
         if(NULL != log) {
-          log::Param params[] = {
+          std::list<log::Param> params = {
             log::Param("category", category),
             log::Param("key", key),
             log::Param("value", value),
@@ -199,7 +199,7 @@ namespace cta { namespace common {
         ss >> value;
 
         if(NULL != log) {
-          log::Param params[] = {
+          std::list<log::Param> params = {
             log::Param("category", category),
             log::Param("key", key),
             log::Param("value", value),

tapeserver/castor/common/CastorConfiguration.cpp

@@ -157,7 +157,7 @@ const std::string& castor::common::CastorConfiguration::getConfEntString(
         // release the lock
         pthread_rwlock_unlock(&m_lock);
         if(NULL != log) {           
-          log::Param params[] = {   
+          std::list<log::Param> params = {   
             log::Param("category", category),
             log::Param("key", key),
             log::Param("value", entIt->second),
@@ -169,7 +169,7 @@ const std::string& castor::common::CastorConfiguration::getConfEntString(
     }
     // no entry found
     if(NULL != log) {
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("category", category),
         log::Param("key", key),
         log::Param("value", defaultValue),
@@ -183,7 +183,7 @@ const std::string& castor::common::CastorConfiguration::getConfEntString(
     pthread_rwlock_unlock(&m_lock);
     // log the exception
     if(NULL != log) {
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("category", category),
         log::Param("key", key),
         log::Param("value", defaultValue),
@@ -235,7 +235,7 @@ const std::string& castor::common::CastorConfiguration::getConfEntString(
     }
 
     if(NULL != log) {
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("category", category),
         log::Param("key", key),
         log::Param("value", entIt->second),

tapeserver/castor/common/CastorConfiguration.hpp

@@ -143,7 +143,7 @@ namespace castor {
           strValue = getConfEntString(category, key);
         } catch(castor::exception::Exception &ex) {
           if(NULL != log) {
-            log::Param params[] = {
+            std::list<log::Param> params = {
               log::Param("category", category),
               log::Param("key", key),
               log::Param("value", defaultValue),
@@ -168,7 +168,7 @@ namespace castor {
         ss >> value;
 
         if(NULL != log) {
-          log::Param params[] = {
+          std::list<log::Param> params = {
             log::Param("category", category),
             log::Param("key", key),
             log::Param("value", value),
@@ -210,7 +210,7 @@ namespace castor {
         ss >> value;
 
         if(NULL != log) {
-          log::Param params[] = {
+          std::list<log::Param> params = {
             log::Param("category", category),
             log::Param("key", key),
             log::Param("value", value),

tapeserver/castor/mediachanger/MmcProxyLog.cpp

@@ -33,7 +33,7 @@ castor::mediachanger::MmcProxyLog::MmcProxyLog(log::Logger &log) throw():
 //------------------------------------------------------------------------------
 void castor::mediachanger::MmcProxyLog::mountTapeReadOnly(
   const std::string &vid, const ManualLibrarySlot &librarySlot) {
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("TPVID", vid),
     log::Param("librarySlot", librarySlot.str())};
   m_log(LOG_WARNING, "Tape should be manual mounted for read-only access",
@@ -45,7 +45,7 @@ void castor::mediachanger::MmcProxyLog::mountTapeReadOnly(
 //------------------------------------------------------------------------------
 void castor::mediachanger::MmcProxyLog::mountTapeReadWrite(
   const std::string &vid, const ManualLibrarySlot &librarySlot) {
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("TPVID", vid),
     log::Param("librarySlot", librarySlot.str())};
   m_log(LOG_WARNING, "Tape should be manual mounted for read/write access",
@@ -57,7 +57,7 @@ void castor::mediachanger::MmcProxyLog::mountTapeReadWrite(
 //------------------------------------------------------------------------------
 void castor::mediachanger::MmcProxyLog::dismountTape(
   const std::string &vid, const ManualLibrarySlot &librarySlot) {
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("TPVID", vid),
     log::Param("librarySlot", librarySlot.str())};
   m_log(LOG_WARNING, "Tape should be manual dismounted", params);
@@ -68,7 +68,7 @@ void castor::mediachanger::MmcProxyLog::dismountTape(
 //------------------------------------------------------------------------------
 void castor::mediachanger::MmcProxyLog::forceDismountTape(
   const std::string &vid, const ManualLibrarySlot &librarySlot) {
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("TPVID", vid),
     log::Param("librarySlot", librarySlot.str())};
   m_log(LOG_WARNING, "Tape should be manual dismounted", params);

tapeserver/castor/tape/reactor/PollReactorImpl.cpp

@@ -102,7 +102,7 @@ void castor::tape::reactor::PollReactorImpl::handleEvents(const int timeout) {
     {
       const int pollErrno = errno;
 
-      log::Param params[] = {
+      std::list<log::Param> params = {
         log::Param("errno", pollErrno),
         log::Param("message", utils::errnoToString(pollErrno))};
       m_log(LOG_ERR, "Failed to handle a pending vdqm request: poll() failed",

tapeserver/castor/tape/reactor/ZMQReactor.cpp

@@ -69,7 +69,7 @@ void castor::tape::reactor::ZMQReactor::registerHandler(
 
   std::ostringstream socketInHex;
   socketInHex << std::hex << item.socket;
-  log::Param params[] = {log::Param("fd", item.fd),
+  std::list<log::Param> params = {log::Param("fd", item.fd),
     log::Param("socket", socketInHex.str())};
   m_log(LOG_DEBUG, "ZMQReactor registering a new handler", params);
 
@@ -114,7 +114,7 @@ void castor::tape::reactor::ZMQReactor::handleEvents(const int timeout) {
     }
   } else if(0 > pollRc) {
     const std::string message = utils::errnoToString(errno);
-    log::Param params[] = {log::Param("message", message)};
+    std::list<log::Param> params = {log::Param("message", message)};
     m_log(LOG_ERR, "Failed to handle I/O event: zmq_poll() failed", params);
   }
 }

tapeserver/castor/tape/tapeserver/daemon/Catalogue.cpp

@@ -174,7 +174,7 @@ void castor::tape::tapeserver::daemon::Catalogue::shutdown() {
     try {
       drive->shutdown();
     } catch(castor::exception::Exception &ex) {
-      log::Param params[] = {log::Param("message", ex.getMessage().str())};
+      std::list<log::Param> params = {log::Param("message", ex.getMessage().str())};
       m_log(LOG_ERR, "Failed to shutdown session", params);
     }
   }
@@ -190,7 +190,7 @@ void castor::tape::tapeserver::daemon::Catalogue::killSessions() {
     try {
       drive->killSession();
     } catch(castor::exception::Exception &ex) {
-      log::Param params[] = {log::Param("message", ex.getMessage().str())};
+      std::list<log::Param> params = {log::Param("message", ex.getMessage().str())};
       m_log(LOG_ERR, "Failed to kill session", params);
     }
   }

tapeserver/castor/tape/tapeserver/daemon/CatalogueLabelSession.cpp

@@ -128,7 +128,7 @@ void castor::tape::tapeserver::daemon::CatalogueLabelSession::
         666, "Unknown error");
     }
   } catch(castor::exception::Exception &we) {
-    log::Param params[] = {log::Param("message", we.getMessage().str())};
+    std::list<log::Param> params = {log::Param("message", we.getMessage().str())};
     m_log(LOG_ERR, "Failed to send failure reply-message to label command",
       params);
   }
@@ -142,7 +142,7 @@ void castor::tape::tapeserver::daemon::CatalogueLabelSession::
   try {
     legacymsg::writeTapeReplyMsg(m_netTimeout, m_labelCmdConnection, 0, "");
   } catch(castor::exception::Exception &we) { 
-    log::Param params[] = {log::Param("message", we.getMessage().str())};
+    std::list<log::Param> params = {log::Param("message", we.getMessage().str())};
     m_log(LOG_ERR, "Failed to send success reply-message to label command",
       params);
   }

tapeserver/castor/tape/tapeserver/daemon/CleanerSession.cpp

@@ -63,7 +63,7 @@ castor::tape::tapeserver::daemon::Session::EndOfSessionAction
   }
 
   // Reaching this point means the cleaner failed and an exception was thrown
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("TPVID", m_vid),
     log::Param("unitName", m_driveConfig.getUnitName()),
     log::Param("message", errorMessage)};
@@ -133,7 +133,7 @@ void castor::tape::tapeserver::daemon::CleanerSession::logAndClearTapeAlerts(dri
       std::vector<std::string> tapeAlerts = drive.getTapeAlerts(tapeAlertCodes);
       for (std::vector<std::string>::iterator ta=tapeAlerts.begin(); ta!=tapeAlerts.end();ta++)
       {
-        log::Param params[] = {
+        std::list<log::Param> params = {
           log::Param("tapeAlert",*ta),
           log::Param("tapeAlertNumber", alertNumber++),
           log::Param("tapeAlertCount", tapeAlerts.size())};
@@ -150,7 +150,7 @@ void castor::tape::tapeserver::daemon::CleanerSession::logAndClearTapeAlerts(dri
   }
 
   // Reaching this point means it failed and an exception was thrown (because of the "return" above)
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("TPVID", m_vid),
     log::Param("unitName", m_driveConfig.getUnitName()),
     log::Param("message", errorMessage)};
@@ -164,7 +164,7 @@ void castor::tape::tapeserver::daemon::CleanerSession::setProcessCapabilities(
   const std::string &capabilities) {
   m_capUtils.setProcText(capabilities);
   {
-    log::Param params[] = {
+    std::list<log::Param> params = {
       log::Param("capabilities", m_capUtils.getProcText())};
     m_log(LOG_INFO, "Cleaner set process capabilities for using tape",
       params);

tapeserver/castor/tape/tapeserver/daemon/EmptyDriveProbe.cpp

@@ -52,7 +52,7 @@ bool castor::tape::tapeserver::daemon::EmptyDriveProbe::driveIsEmpty() throw() {
   }
 
   // Reaching this point means the probe failed and an exception was thrown
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("unitName", m_driveConfig.getUnitName()),
     log::Param("message", errorMessage)};
   m_log(LOG_ERR, "Probe failed", params);

tapeserver/castor/tape/tapeserver/daemon/ProcessForker.cpp

@@ -124,13 +124,13 @@ bool castor::tape::tapeserver::daemon::ProcessForker::handleEvents() throw() {
   try {
     return handlePendingMsgs() && handlePendingSignals();
   } catch(castor::exception::Exception &ex) {
-    log::Param params[] = {log::Param("message", ex.getMessage().str())};
+    std::list<log::Param> params = {log::Param("message", ex.getMessage().str())};
     m_log(LOG_ERR, "ProcessForker failed to handle events", params);
   } catch(std::exception &se) {
-    log::Param params[] = {log::Param("message", se.what())};
+    std::list<log::Param> params = {log::Param("message", se.what())};
     m_log(LOG_ERR, "ProcessForker failed to handle events", params);
   } catch(...) {
-    log::Param params[] =
+    std::list<log::Param> params =
       {log::Param("message", "Caught an unknown exception")};
     m_log(LOG_ERR, "ProcessForker failed to handle events", params);
   }
@@ -171,7 +171,7 @@ bool castor::tape::tapeserver::daemon::ProcessForker::thereIsAPendingMsg() {
   case -1: // Error
     {
       const std::string message = castor::utils::errnoToString(errno);
-      log::Param params[] = {log::Param("message", message)};
+      std::list<log::Param> params = {log::Param("message", message)};
       m_log(LOG_ERR,
         "Error detected when checking for a pending ProcessForker message",
         params);
@@ -184,7 +184,7 @@ bool castor::tape::tapeserver::daemon::ProcessForker::thereIsAPendingMsg() {
       std::ostringstream message;
       message << "poll returned an unexpected value"
         ": expected=0 or 1 actual=" << pollRc;
-      log::Param params[] = {log::Param("message", message.str())};
+      std::list<log::Param> params = {log::Param("message", message.str())};
       m_log(LOG_ERR,
         "Error detected when checking for a pending ProcessForker message",
         params);
@@ -207,7 +207,7 @@ bool castor::tape::tapeserver::daemon::ProcessForker::handleMsg() {
     throw ex;
   }
 
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("type", messages::msgTypeToString(frame.type)),
     log::Param("len", frame.payload.length())};
   m_log(LOG_INFO, "ProcessForker handling a ProcessForker message", params);
@@ -245,7 +245,7 @@ bool castor::tape::tapeserver::daemon::ProcessForker::handleMsg() {
 
   ProcessForkerUtils::writeFrame(m_cmdSocket, result.reply);
   {
-    log::Param params[] = {
+    std::list<log::Param> params = {
       log::Param("payloadType",
         messages::msgTypeToString(result.reply.type)),
       log::Param("payloadLen", result.reply.payload.length())};
@@ -310,7 +310,7 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
 
   // Else if this is the parent process
   } else if(0 < forkRc) {
-    log::Param params[] = {log::Param("pid", forkRc)};
+    std::list<log::Param> params = {log::Param("pid", forkRc)};
     m_log(LOG_INFO, "ProcessForker forked cleaner session", params);
 
     return createForkSucceededResult(forkRc, true);
@@ -324,13 +324,13 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
     try {
       exit(runCleanerSession(rqst));
     } catch(castor::exception::Exception &ne) {
-      log::Param params[] = {log::Param("message", ne.getMessage().str())};
+      std::list<log::Param> params = {log::Param("message", ne.getMessage().str())};
       m_log(LOG_ERR, "Cleaner session failed", params);
     } catch(std::exception &ne) {
-      log::Param params[] = {log::Param("message", ne.what())};
+      std::list<log::Param> params = {log::Param("message", ne.what())};
       m_log(LOG_ERR, "Cleaner session failed", params);
     } catch(...) {
-      log::Param params[] = {log::Param("message",
+      std::list<log::Param> params = {log::Param("message",
         "Caught an unknown exception")};
       m_log(LOG_ERR, "Cleaner session failed", params);
     }
@@ -363,7 +363,7 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
       "Failed to fork data-transfer session for tape drive", true);
   // Else if this is the parent process
   } else if(0 < forkRc) {
-    log::Param params[] = {log::Param("pid", forkRc)};
+    std::list<log::Param> params = {log::Param("pid", forkRc)};
     m_log(LOG_INFO, "ProcessForker forked data-transfer session", params);
 
     return createForkSucceededResult(forkRc, true);
@@ -377,13 +377,13 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
     try {
       exit(runDataTransferSession(rqst));
     } catch(castor::exception::Exception &ne) {
-      log::Param params[] = {log::Param("message", ne.getMessage().str())};
+      std::list<log::Param> params = {log::Param("message", ne.getMessage().str())};
       m_log(LOG_ERR, "Data-transfer session failed", params);
     } catch(std::exception &ne) {
-      log::Param params[] = {log::Param("message", ne.what())};
+      std::list<log::Param> params = {log::Param("message", ne.what())};
       m_log(LOG_ERR, "Data-transfer session failed", params);
     } catch(...) {
-      log::Param params[] = {log::Param("message",
+      std::list<log::Param> params = {log::Param("message",
         "Caught an unknown exception")};
       m_log(LOG_ERR, "Data-transfer session failed", params);
     }
@@ -417,7 +417,7 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
 
   // Else if this is the parent process
   } else if(0 < forkRc) {
-    log::Param params[] = {log::Param("pid", forkRc)};
+    std::list<log::Param> params = {log::Param("pid", forkRc)};
     m_log(LOG_INFO, "ProcessForker forked label session", params);
 
     return createForkSucceededResult(forkRc, true);
@@ -431,13 +431,13 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
     try {
       exit(runLabelSession(rqst));
     } catch(castor::exception::Exception &ne) {
-      log::Param params[] = {log::Param("message", ne.getMessage().str())};
+      std::list<log::Param> params = {log::Param("message", ne.getMessage().str())};
       m_log(LOG_ERR, "Label session failed", params);
     } catch(std::exception &ne) {
-      log::Param params[] = {log::Param("message", ne.what())};
+      std::list<log::Param> params = {log::Param("message", ne.what())};
       m_log(LOG_ERR, "Label session failed", params);
     } catch(...) {
-      log::Param params[] = {log::Param("message",
+      std::list<log::Param> params = {log::Param("message",
         "Caught an unknown exception")};
       m_log(LOG_ERR, "Label session failed", params);
     }
@@ -457,7 +457,7 @@ castor::tape::tapeserver::daemon::ProcessForker::MsgHandlerResult
   ProcessForkerUtils::parsePayload(frame, rqst);
 
   // Log the fact that the ProcessForker will not gracefully stop
-  log::Param params[] = {log::Param("reason", rqst.reason())};
+  std::list<log::Param> params = {log::Param("reason", rqst.reason())};
   m_log(LOG_INFO, "Gracefully stopping ProcessForker", params);
 
   return createReturnValueResult(0, false);
@@ -627,7 +627,7 @@ void *castor::tape::tapeserver::daemon::ProcessForker::instantiateZmqContext(
 
   std::ostringstream contextAddr;
   contextAddr << std::hex << zmqContext;
-  log::Param params[] = {log::Param("contextAddr", contextAddr.str())};
+  std::list<log::Param> params = {log::Param("contextAddr", contextAddr.str())};
   m_log(LOG_INFO, "Child of ProcessForker instantiated a ZMQ context", params);
 
   return zmqContext;
@@ -757,7 +757,7 @@ void castor::tape::tapeserver::daemon::ProcessForker::
     msg.set_pid(pid);
     msg.set_exitcode(WEXITSTATUS(waitpidStat));
 
-    log::Param params[] = {
+    std::list<log::Param> params = {
       log::Param("pid", msg.pid()),
       log::Param("exitCode", msg.exitcode()),
       log::Param("payloadLen", msg.ByteSize())};
@@ -793,7 +793,7 @@ void castor::tape::tapeserver::daemon::ProcessForker::
     msg.set_pid(pid);
     msg.set_signal(WTERMSIG(waitpidStat));
 
-    log::Param params[] = {log::Param("pid", msg.pid()),
+    std::list<log::Param> params = {log::Param("pid", msg.pid()),
       log::Param("signal", msg.signal())};
     m_log(LOG_WARNING, "ProcessForker notifying TapeDaemon of process crash",
       params);

tapeserver/castor/tape/tapeserver/daemon/ProcessForkerConnectionHandler.cpp

@@ -48,7 +48,7 @@ castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
 //------------------------------------------------------------------------------
 castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
   ~ProcessForkerConnectionHandler() throw() {
-  log::Param params[] = {log::Param("fd", m_fd)};
+  std::list<log::Param> params = {log::Param("fd", m_fd)};
   m_log(LOG_DEBUG, "Closing incoming connection from the ProcessForker",
     params);
   close(m_fd);
@@ -90,7 +90,7 @@ bool castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
 //------------------------------------------------------------------------------
 void castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
   logConnectionEvent(const zmq_pollitem_t &fd)  {
-  log::Param params[] = {
+  std::list<log::Param> params = {
   log::Param("fd", fd.fd),
   log::Param("ZMQ_POLLIN", fd.revents & ZMQ_POLLIN ? "true" : "false"),
   log::Param("ZMQ_POLLOUT", fd.revents & ZMQ_POLLOUT ? "true" : "false"),
@@ -122,7 +122,7 @@ bool castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
     const int timeout = 10; // Timeout in seconds
     frame = ProcessForkerUtils::readFrame(m_fd, timeout);
   } catch(castor::exception::Exception &ne) {
-    log::Param params[] = {log::Param("message", ne.getMessage().str())};
+    std::list<log::Param> params = {log::Param("message", ne.getMessage().str())};
     m_log(LOG_ERR, "ProcessForkerConnectionHandler failed to handle message"
       ": Failed to read frame", params);
 
@@ -131,7 +131,7 @@ bool castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
     return true; // Ask reactor to remove and delete this event handler
   }
 
-  log::Param params[] = {
+  std::list<log::Param> params = {
     log::Param("type", messages::msgTypeToString(frame.type)),
     log::Param("payloadLen", frame.payload.length())};
   m_log(LOG_INFO, "ProcessForkerConnectionHandler handling a message", params);
@@ -139,7 +139,7 @@ bool castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
   try {
     dispatchMsgHandler(frame);
   } catch(castor::exception::Exception &ne) {
-    log::Param params[] = {log::Param("message", ne.getMessage().str())};
+    std::list<log::Param> params = {log::Param("message", ne.getMessage().str())};
     m_log(LOG_ERR, "ProcessForkerConnectionHandler failed to handle message",
       params);
 
@@ -163,7 +163,7 @@ void castor::tape::tapeserver::daemon::ProcessForkerConnectionHandler::
       return handleProcessExitedMsg(frame);
     default:
       {
-        log::Param params[] = {
+        std::list<log::Param> params = {
           log::Param("type", frame.type),
           log::Param("typeStr", messages::msgTypeToString(frame.type))};
         m_log(LOG_ERR, "ProcessForkerConnectionHandler failed to dispatch"

tapeserver/castor/tape/tapeserver/daemon/ProcessForkerProxySocket.cpp

@@ -46,7 +46,7 @@ castor::tape::tapeserver::daemon::ProcessForkerProxySocket::
   ~ProcessForkerProxySocket() throw() {
   if(-1 == close(m_socketFd)) {
     const std::string message = castor::utils::errnoToString(errno);
-    log::Param params[] = {log::Param("socketFd", m_socketFd), 
+    std::list<log::Param> params = {log::Param("socketFd", m_socketFd), 
       log::Param("message", message)};
     m_log(LOG_ERR,
       "Failed to close proxy side of ProcessForker socket pair", params);
@@ -106,7 +106,7 @@ pid_t castor::tape::tapeserver::daemon::ProcessForkerProxySocket::
   const int timeout = 10; // Timeout in seconds
   messages::ForkSucceeded reply;
   ProcessForkerUtils::readReplyOrEx(m_socketFd, timeout, reply);
-  log::Param params[] = {log::Param("pid", reply.pid())};
+  std::list<log::Param> params = {log::Param("pid", reply.pid())};
   m_log(LOG_INFO,
     "Got process ID of the data-transfer session from the ProcessForker",
     params);
@@ -143,7 +143,7 @@ pid_t castor::tape::tapeserver::daemon::ProcessForkerProxySocket::
   const int timeout = 10; // Timeout in seconds
   messages::ForkSucceeded reply;
   ProcessForkerUtils::readReplyOrEx(m_socketFd, timeout, reply);
-  log::Param params[] = {log::Param("pid", reply.pid())};
+  std::list<log::Param> params = {log::Param("pid", reply.pid())};
   m_log(LOG_INFO, "Got process ID of the label session from the ProcessForker",
     params);
 
@@ -185,7 +185,7 @@ pid_t castor::tape::tapeserver::daemon::ProcessForkerProxySocket::
   const int timeout = 10; // Timeout in seconds
   messages::ForkSucceeded reply;
   ProcessForkerUtils::readReplyOrEx(m_socketFd, timeout, reply);
-  log::Param params[] = {log::Param("pid", reply.pid())};
+  std::list<log::Param> params = {log::Param("pid", reply.pid())};
   m_log(LOG_INFO,
     "Got process ID of the cleaner session from the ProcessForker", params);
 

tapeserver/castor/tape/tapeserver/daemon/ProcessForkerUtils.cpp

@@ -268,7 +268,7 @@ void castor::tape::tapeserver::daemon::ProcessForkerUtils::
     writeUint32(fd, payloadLen);
 
     if(NULL != log) {
-      log::Param params[] = {log::Param("type", messages::msgTypeToString(type)),
+      std::list<log::Param> params = {log::Param("type", messages::msgTypeToString(type)),
         log::Param("payloadLen", payloadLen)};
       (*log)(LOG_DEBUG, "ProcessForkerUtils wrote frame header", params);
     }
@@ -318,7 +318,7 @@ void castor::tape::tapeserver::daemon::ProcessForkerUtils::
     writeString(fd, msgStr, log);
 
     if(NULL != log) {
-      log::Param params[] = {log::Param("payloadLen", msgStr.length())};
+      std::list<log::Param> params = {log::Param("payloadLen", msgStr.length())};
       (*log)(LOG_DEBUG, "ProcessForkerUtils wrote frame payload", params);
     }
   } catch(castor::exception::Exception &ne) {
@@ -384,7 +384,7 @@ void castor::tape::tapeserver::daemon::ProcessForkerUtils::
   }
 
   if(NULL != log) {
-    log::Param params[] = {log::Param("length",  str.length())};
+    std::list<log::Param> params = {log::Param("length",  str.length())};
     (*log)(LOG_DEBUG, "ProcessForkerUtils wrote string", params);
   }
 }

tapeserver/castor/tape/tapeserver/daemon/TapeDaemon.cpp

@@ -138,7 +138,7 @@ void castor::tape::tapeserver::daemon::TapeDaemon::destroyZmqContext() throw() {
   if(NULL != m_zmqContext) {
     if(zmq_term(m_zmqContext)) {
       const std::string message = castor::utils::errnoToString(errno);
-      castor::log::Param params[] = {castor::log::Param("message", message)};
+      std::list<castor::log::Param> params = {castor::log::Param("message", message)};
       m_log(LOG_ERR, "Failed to destroy ZMQ context", params);
     } else {
       m_zmqContext = NULL;
@@ -161,7 +161,7 @@ int castor::tape::tapeserver::daemon::TapeDaemon::main() throw() {
       << std::endl;
 
     // Log the error
-    log::Param params[] = {
+    std::list<log::Param> params = {
       log::Param("Message", ex.getMessage().str()),
       log::Param("Code"   , ex.code())};