branching/tagging

8 files changed, 460 insertions, 0 deletions

diff --git a/modules/CIAO/ciao/Logger/CIAOLoggerFactory.h b/modules/CIAO/ciao/Logger/CIAOLoggerFactory.h
new file mode 100644
index 00000000000..3abee97aaf1
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/CIAOLoggerFactory.h
@@ -0,0 +1,19 @@
+// $Id$
+#ifndef LOGGERFACTORY_H_
+#define LOGGERFACTORY_H_
+
+#include "ace/Service_Object.h"
+#include "tao/ORB.h"
+#include "ace/Log_Msg_Backend.h"
+
+namespace CIAO
+  {
+
+  class CIAOLoggerFactory : public ACE_Service_Object
+    {
+    public:
+      virtual ACE_Log_Msg_Backend * get_logger_backend (CORBA::ORB_ptr orb) = 0;
+    };
+} // CIAO
+
+#endif /*LOGGERFACTORY_H_*/
diff --git a/modules/CIAO/ciao/Logger/CIAO_Logger_Export.h b/modules/CIAO/ciao/Logger/CIAO_Logger_Export.h
new file mode 100644
index 00000000000..b1760b426f9
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/CIAO_Logger_Export.h
@@ -0,0 +1,58 @@
+
+// -*- C++ -*-
+// $Id$
+// Definition for Win32 Export directives.
+// This file is generated automatically by generate_export_file.pl CIAO_Logger
+// ------------------------------
+#ifndef CIAO_LOGGER_EXPORT_H
+#define CIAO_LOGGER_EXPORT_H
+
+#include "ace/config-all.h"
+
+#if defined (ACE_AS_STATIC_LIBS) && !defined (CIAO_LOGGER_HAS_DLL)
+#  define CIAO_LOGGER_HAS_DLL 0
+#endif /* ACE_AS_STATIC_LIBS && CIAO_LOGGER_HAS_DLL */
+
+#if !defined (CIAO_LOGGER_HAS_DLL)
+#  define CIAO_LOGGER_HAS_DLL 1
+#endif /* ! CIAO_LOGGER_HAS_DLL */
+
+#if defined (CIAO_LOGGER_HAS_DLL) && (CIAO_LOGGER_HAS_DLL == 1)
+#  if defined (CIAO_LOGGER_BUILD_DLL)
+#    define CIAO_Logger_Export ACE_Proper_Export_Flag
+#    define CIAO_LOGGER_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T)
+#    define CIAO_LOGGER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  else /* CIAO_LOGGER_BUILD_DLL */
+#    define CIAO_Logger_Export ACE_Proper_Import_Flag
+#    define CIAO_LOGGER_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T)
+#    define CIAO_LOGGER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#  endif /* CIAO_LOGGER_BUILD_DLL */
+#else /* CIAO_LOGGER_HAS_DLL == 1 */
+#  define CIAO_Logger_Export
+#  define CIAO_LOGGER_SINGLETON_DECLARATION(T)
+#  define CIAO_LOGGER_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK)
+#endif /* CIAO_LOGGER_HAS_DLL == 1 */
+
+// Set CIAO_LOGGER_NTRACE = 0 to turn on library specific tracing even if
+// tracing is turned off for ACE.
+#if !defined (CIAO_LOGGER_NTRACE)
+#  if (ACE_NTRACE == 1)
+#    define CIAO_LOGGER_NTRACE 1
+#  else /* (ACE_NTRACE == 1) */
+#    define CIAO_LOGGER_NTRACE 0
+#  endif /* (ACE_NTRACE == 1) */
+#endif /* !CIAO_LOGGER_NTRACE */
+
+#if (CIAO_LOGGER_NTRACE == 1)
+#  define CIAO_LOGGER_TRACE(X)
+#else /* (CIAO_LOGGER_NTRACE == 1) */
+#  if !defined (ACE_HAS_TRACE)
+#    define ACE_HAS_TRACE
+#  endif /* ACE_HAS_TRACE */
+#  define CIAO_LOGGER_TRACE(X) ACE_TRACE_IMPL(X)
+#  include "ace/Trace.h"
+#endif /* (CIAO_LOGGER_NTRACE == 1) */
+
+#endif /* CIAO_LOGGER_EXPORT_H */
+
+// End of auto generated file.
diff --git a/modules/CIAO/ciao/Logger/File_Logger_Backend.cpp b/modules/CIAO/ciao/Logger/File_Logger_Backend.cpp
new file mode 100644
index 00000000000..b4a25d0d1b1
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/File_Logger_Backend.cpp
@@ -0,0 +1,46 @@
+// $Id$
+#include "File_Logger_Backend.h"
+#include "ace/OS_NS_stdio.h"
+#include "ace/Log_Record.h"
+#include "ace/Log_Msg.h"
+#include "ciao/CIAO_common.h"
+
+namespace CIAO
+{
+
+  int
+  File_Logger_Backend::open (const ACE_TCHAR *)
+  {
+    CIAO_DEBUG ( (LM_DEBUG, CLINFO "Setting logger's output to file \"%s\"", this->filename_.c_str()));
+    this->fh_ = ACE_OS::fopen (this->filename_.c_str(), "w");
+    if (0 == this->fh_)
+      {
+        ACE_CString s = "Failed to open log file \"";
+        s += ACE_TEXT_ALWAYS_CHAR (this->filename_.c_str ());
+        s += "\"";
+        throw LoggerError (s.c_str());
+      }
+    return 0;
+  }
+
+  int
+  File_Logger_Backend::close (void)
+  {
+    if (0 != this->fh_)
+      {
+        ACE_OS::fclose (this->fh_);
+        this->fh_ = 0;
+      }
+    return 0;
+  }
+
+  ssize_t
+  File_Logger_Backend::log (ACE_Log_Record &log_record)
+  {
+    int res = log_record.print (0, ACE_Log_Msg::VERBOSE, this->fh_);
+    ACE_OS::fflush (this->fh_);
+    return res;
+  }
+
+}
+
diff --git a/modules/CIAO/ciao/Logger/File_Logger_Backend.h b/modules/CIAO/ciao/Logger/File_Logger_Backend.h
new file mode 100644
index 00000000000..99b899484c2
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/File_Logger_Backend.h
@@ -0,0 +1,52 @@
+// $Id$
+#ifndef FILE_LOGGER_BACKEND_H_
+#define FILE_LOGGER_BACKEND_H_
+
+#include "ace/Log_Msg_Backend.h"
+#include "ace/SString.h"
+//#include "ace/String_Base.h"
+
+#include "CIAO_Logger_Export.h"
+
+namespace CIAO
+  {
+
+  class CIAO_Logger_Export LoggerError
+    {
+    public:
+      LoggerError (const char * msg)
+          : errmsg_ (msg) {};
+      ACE_CString errmsg_;
+    };
+
+  class CIAO_Logger_Export File_Logger_Backend : public ACE_Log_Msg_Backend
+    {
+    public:
+      File_Logger_Backend (const ACE_TCHAR * fname)
+          : fh_ (0), filename_ (fname) {}
+
+      virtual ~File_Logger_Backend (void)
+      {
+        this->close();
+      };
+
+      virtual int open (const ACE_TCHAR *logger_key);
+
+      virtual int reset (void)
+      {
+        this->close();
+        return this->open (0);
+      };
+
+      virtual int close (void);
+
+      virtual ssize_t log (ACE_Log_Record &log_record);
+
+    private:
+      FILE * fh_;
+      ACE_TString filename_;
+    };
+
+} // CIAO
+
+#endif /*FILE_LOGGER_BACKEND_H_*/
diff --git a/modules/CIAO/ciao/Logger/Log_Macros.h b/modules/CIAO/ciao/Logger/Log_Macros.h
new file mode 100644
index 00000000000..d6c7744e539
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/Log_Macros.h
@@ -0,0 +1,82 @@
+// $Id$
+/**
+ * @file Log_Macros.h
+ * @author William R. Otte <wotte@dre.vanderbilt.edu>
+ *
+ * Macros used for logging in CIAO.
+ */
+
+#ifndef CIAO_LOG_MACROS_H_
+#define CIAO_LOG_MACROS_H_
+
+// default information printed with CIAO logging messages.
+
+#define CLINFO "(%P|%t) [%M] - %T - "
+
+#if (CIAO_NTRACE == 1)
+#  if !defined (ACE_NTRACE)
+#    define CIAO_TRACE(X) do {} while (0)
+#    define CIAO_ENABLE_TRACE(X) do {} while (0)
+#    define CIAO_DISABLE_TRACE(X) do {} while (0)
+#  else
+#    if (ACE_NTRACE == 0)
+#      error CIAO_TRACE cannot be disabled if ACE_TRACE is enabled
+#    else
+#      define CIAO_TRACE(X) do {} while (0)
+#      define CIAO_ENABLE_TRACE(X) do {} while (0)
+#      define CIAO_DISABLE_TRACE(X) do {} while (0)
+#    endif
+#  endif
+#else
+#  if !defined (ACE_HAS_TRACE)
+#    define ACE_HAS_TRACE
+#  endif /* ACE_HAS_TRACE */
+#  define CIAO_TRACE(X) ACE_TRACE_IMPL(X)
+#  define CIAO_ENABLE_TRACE() ACE_Trace::start_tracing ()
+#  define CIAO_DISABLE_TRACE() ACE_Trace::stop_tracing ()
+#  undef CLINFO // Make log messages indent with tracing.
+#  define CLINFO "%I(%P|%t) [%M] - %T - "
+#  include "ace/Trace.h"
+#endif /* CIAO_NTRACE */
+
+#if defined (CIAO_NLOGGING)
+# define CIAO_ERROR(X) do {} while (0)
+# define CIAO_DEBUG(X) do {} while (0)
+#define CIAO_ERROR_RETURN(X, Y) return (Y)
+#define CIAO_ERROR_BREAK(X) { break; }
+#else
+# if !defined (CIAO_ERROR)
+#  define CIAO_ERROR(X) \
+  do { \
+    int __ace_error = ACE_Log_Msg::last_error_adapter (); \
+    ACE_Log_Msg *ace___ = ACE_Log_Msg::instance ();               \
+    ace___->conditional_set (__FILE__, __LINE__, -1, __ace_error); \
+    ace___->log X; \
+  } while (0)
+#  endif
+# if !defined (CIAO_DEBUG)
+#  define CIAO_DEBUG(X) \
+  do { \
+    int __ace_error = ACE_Log_Msg::last_error_adapter (); \
+    ACE_Log_Msg *ace___ = ACE_Log_Msg::instance (); \
+    ace___->conditional_set (__FILE__, __LINE__, 0, __ace_error); \
+    ace___->log X; \
+  } while (0)
+# endif
+# if !defined (CIAO_ERROR_RETURN)
+#  define CIAO_ERROR_RETURN(X, Y) \
+  do { \
+    int __ace_error = ACE_Log_Msg::last_error_adapter (); \
+    ACE_Log_Msg *ace___ = ACE_Log_Msg::instance (); \
+    ace___->conditional_set (__FILE__, __LINE__, Y, __ace_error); \
+    ace___->log X; \
+    return Y; \
+  } while (0)
+# endif
+# if !defined (CIAO_ERROR_BREAK)
+#  define CIAO_ERROR_BREAK(X) { CIAO_ERROR (X); break; }
+# endif
+#endif
+
+
+#endif
diff --git a/modules/CIAO/ciao/Logger/Logger.mpc b/modules/CIAO/ciao/Logger/Logger.mpc
new file mode 100644
index 00000000000..642071d4abe
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/Logger.mpc
@@ -0,0 +1,18 @@
+// -*- MPC -*-
+// $Id$
+
+project(CIAO_Logger): ciao_lib, messaging {
+  sharedname   = CIAO_Logger
+  dynamicflags = CIAO_LOGGER_BUILD_DLL
+
+  Source_Files {
+    File_Logger_Backend.cpp
+    Logger_Service.cpp  
+  }
+  Header_Files {
+  }
+}
+
+    
+
+
diff --git a/modules/CIAO/ciao/Logger/Logger_Service.cpp b/modules/CIAO/ciao/Logger/Logger_Service.cpp
new file mode 100644
index 00000000000..d5c1c9c5fbf
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/Logger_Service.cpp
@@ -0,0 +1,151 @@
+// $Id$
+#include "Logger_Service.h"
+#include "Log_Macros.h"
+#include "ace/Get_Opt.h"
+#include "ace/CORBA_macros.h"
+#include "ace/Env_Value_T.h"
+#include "tao/SystemException.h"
+
+namespace CIAO
+{
+  Logger_Service::Logger_Service (void)
+    : filename_ (ACE_TEXT("")),
+      trace_ (false),
+      log_level_ (5)
+  {
+  }
+
+  int
+  Logger_Service::init (int argc, ACE_TCHAR * argv[])
+  {
+    // Get prospective values from the environment first, those given on
+    // command line can override
+    ACE_Env_Value<int> log (ACE_TEXT("CIAO_LOG_LEVEL"), this->log_level_);
+    this->log_level_ = log;
+
+    ACE_Env_Value<int> trace (ACE_TEXT("CIAO_TRACE_ENABLE"), this->trace_);
+    this->trace_ = trace;
+
+    ACE_Env_Value<const ACE_TCHAR *> filename (ACE_TEXT("CIAO_LOG_FILE"), this->filename_.c_str ());
+    this->filename_ = filename;
+
+    this->parse_args (argc, argv);
+    this->set_levels ();
+
+    return 0;
+  }
+
+  void
+  Logger_Service::parse_args (int argc, ACE_TCHAR **argv)
+  {
+    const ACE_TCHAR *shortl = ACE_TEXT("-l");
+    const ACE_TCHAR *longl = ACE_TEXT("--log-level");
+    const ACE_TCHAR *tracel = ACE_TEXT("--trace");
+    const ACE_TCHAR *traces = ACE_TEXT("-t");
+    const ACE_TCHAR *lfl = ACE_TEXT("--log-file");
+    const ACE_TCHAR *lfs = ACE_TEXT("-f");
+
+    // We need to actually FIND the -l option, as the get_opt won't ignore
+    // the ORB options and such.
+    for (int i = 0; i < argc; ++i)
+      {
+        if (ACE_OS::strncmp (argv[i], traces, 2) == 0 ||
+            ACE_OS::strncmp (argv[i], tracel, 7) == 0)
+          {
+            this->trace_ = true;
+            continue;
+          }
+
+        if (ACE_OS::strncmp (argv[i], shortl, 2) == 0 ||
+            ACE_OS::strncmp (argv[i], longl,11 ) == 0)
+          {
+            if ((i + 1) < argc && *argv[i + 1] != '-')
+              {
+                int level = ACE_OS::atoi (argv[i + 1]);
+
+                if (level != 0)
+                  this->log_level_ = level;
+              }
+          }
+
+        if (ACE_OS::strncmp (argv[i], lfs, 2) == 0 ||
+            ACE_OS::strncmp (argv[i], lfl, 10 ) == 0)
+          {
+            if ((i + 1) < argc && *argv[i + 1] != '-')
+              {
+                this->filename_ = argv[i+1];
+              }
+          }
+      }
+  }
+
+  void
+  Logger_Service::set_levels (void)
+  {
+    if (this->trace_)
+      {
+        CIAO_ENABLE_TRACE ();
+        this->log_level_ = 10;
+      }
+    else
+      {
+        CIAO_DISABLE_TRACE ();
+      }
+
+    u_long new_mask = 0;
+
+    if (this->log_level_ >= 9)
+      {
+        new_mask |= LM_TRACE;
+      }
+    if (this->log_level_ >= 8)
+      {
+        new_mask |= LM_DEBUG;
+      }
+    if (this->log_level_ >= 7)
+      {
+        new_mask |= LM_INFO;
+      }
+    if (this->log_level_ >= 6)
+      {
+        new_mask |= LM_NOTICE;
+      }
+    if (this->log_level_ >= 5)
+      {
+        new_mask |= LM_WARNING;
+      }
+    if (this->log_level_ >= 4)
+      {
+        new_mask |= LM_ERROR;
+      }
+    if (this->log_level_ >= 3)
+      {
+        new_mask |= LM_CRITICAL;
+      }
+    if (this->log_level_ >= 2)
+      {
+        new_mask |= LM_ALERT;
+      }
+    if (this->log_level_ >= 1)
+      {
+        new_mask |= LM_EMERGENCY;
+      }
+    ACE_Log_Msg::instance()->priority_mask(new_mask, ACE_Log_Msg::PROCESS);
+    CIAO_DEBUG ( (LM_TRACE, CLINFO "Logging level is set to %i\n", this->log_level_));
+  }
+
+  ACE_Log_Msg_Backend *
+  Logger_Service::get_logger_backend (CORBA::ORB_ptr)
+  {
+    File_Logger_Backend * the_backend;
+    ACE_NEW_THROW_EX (the_backend,
+                      File_Logger_Backend (this->filename_.c_str()),
+                      CORBA::NO_MEMORY());
+    return the_backend;
+  }
+
+} // CIAO
+
+using namespace CIAO;
+ACE_FACTORY_DEFINE (CIAO_Logger, Logger_Service)
+
diff --git a/modules/CIAO/ciao/Logger/Logger_Service.h b/modules/CIAO/ciao/Logger/Logger_Service.h
new file mode 100644
index 00000000000..0ebbd53d57e
--- /dev/null
+++ b/modules/CIAO/ciao/Logger/Logger_Service.h
@@ -0,0 +1,34 @@
+// $Id$
+#ifndef CIAO_LOGGER_SERVICE_H_
+#define CIAO_LOGGER_SERVICE_H_
+
+#include "CIAO_Logger_Export.h"
+#include "CIAOLoggerFactory.h"
+#include "File_Logger_Backend.h"
+
+namespace CIAO
+  {
+
+  class CIAO_Logger_Export Logger_Service : public CIAOLoggerFactory
+    {
+    public:
+      Logger_Service (void);
+
+      virtual int init (int argc, ACE_TCHAR * argv[]);
+      virtual ACE_Log_Msg_Backend * get_logger_backend (CORBA::ORB_ptr orb);
+
+    private:
+
+      void parse_args (int argc, ACE_TCHAR **argv);
+      void set_levels (void);
+
+      ACE_TString filename_;
+      bool trace_;
+      int log_level_;
+    };
+
+} // DAnCE
+
+ACE_FACTORY_DECLARE (CIAO_Logger, Logger_Service)
+
+#endif /*LOGGER_SERVICE_H_*/