src/SALOMETraceCollector/SALOMETraceCollector.cxx

   1 // Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 //  File   : LocalTraceCollector.cxx
  24 //  Author : Paul RASCLE (EDF)
  25 //  Module : KERNEL
  26 //  $Header$
  27 //
  28 #include <SALOMEconfig.h>
  29
  30 #include <iostream>
  31 #include <sstream>
  32 #include <fstream>
  33 #include <cstdlib>
  34 #include <omniORB4/CORBA.h>
  35
  36 #include "Utils_SALOME_Exception.hxx"
  37 #include "SALOMETraceCollector.hxx"
  38 #include "TraceCollector_WaitForServerReadiness.hxx"
  39 #include <SALOMEconfig.h>
  40 #include CORBA_CLIENT_HEADER(Logger)
  41
  42 // ============================================================================
  43 /*!
  44  *  This class is for use with CORBA, inside SALOME.
  45  *  Type of trace (and corresponding class) is chosen in LocalTraceBufferPool.
  46  *
  47  *  Guarantees a unique object instance of the class (singleton thread safe)
  48  *  a separate thread for loop to print traces is launched.
  49  */
  50 // ============================================================================
  51
  52 BaseTraceCollector* SALOMETraceCollector::instance()
  53 {
  54   if (_singleton == 0) // no need of lock when singleton already exists
  55     {
  56       pthread_mutex_lock(&_singletonMutex);    // acquire lock to be alone
  57       if (_singleton == 0)                     // another thread may have got
  58         {                                      // the lock after the first test
  59           BaseTraceCollector* myInstance = new SALOMETraceCollector();
  60
  61           sem_init(&_sem,0,0); // to wait until run thread is initialized
  62           pthread_t traceThread;
  63           int bid = 0;
  64           pthread_create(&traceThread, NULL,
  65                                    SALOMETraceCollector::run, &bid);
  66           sem_wait(&_sem);
  67           _singleton = myInstance; // _singleton known only when init done
  68         }
  69       pthread_mutex_unlock(&_singletonMutex); // release lock
  70     }
  71   return _singleton;
  72 }
  73
  74 // ============================================================================
  75 /*!
  76  *  In a separate thread, loop to print traces.
  77  *  Mutex guarantees initialisation on instance method is done and only one run
  78  *  allowed (double check ...)
  79  *  Loop until there is no more buffer to print,
  80  *  and no ask for end from destructor.
  81  *  Get a buffer. If type = ABORT then exit application with message.
  82  */
  83 // ============================================================================
  84
  85 void* SALOMETraceCollector::run(void* /*bid*/)
  86 {
  87   _threadId = new pthread_t;
  88   *_threadId = pthread_self();
  89   sem_post(&_sem); // unlock instance
  90
  91   LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
  92   LocalTrace_TraceInfo myTrace;
  93
  94   SALOME_Logger::Logger_var m_pInterfaceLogger;
  95   CORBA::Object_var obj;
  96
  97   obj = TraceCollector_WaitForServerReadiness("Logger");
  98   if (!CORBA::is_nil(obj))
  99     m_pInterfaceLogger = SALOME_Logger::Logger::_narrow(obj);
 100   if (CORBA::is_nil(m_pInterfaceLogger))
 101     {
 102       std::cerr << "Logger server not found ! Abort" << std::endl;
 103       std::cerr << std::flush ;
 104       exit(1);
 105     }
 106   else
 107     {
 108       CORBA::String_var LogMsg =
 109         CORBA::string_dup("\n---Init logger trace---\n");
 110       m_pInterfaceLogger->putMessage(LogMsg);
 111       DEVTRACE("Logger server found");
 112     }
 113
 114   // --- Loop until there is no more buffer to print,
 115   //     and no ask for end from destructor.
 116
 117   while ((!_threadToClose) || myTraceBuffer->toCollect() )
 118     {
 119       if (_threadToClose)
 120         {
 121           DEVTRACE("SALOMETraceCollector _threadToClose");
 122           //break;
 123         }
 124
 125       myTraceBuffer->retrieve(myTrace);
 126       {
 127         if (myTrace.traceType == ABORT_MESS)
 128           {
 129             std::ostringstream abortMessage;
 130             abortMessage << "INTERRUPTION from thread : " << myTrace.trace;
 131             CORBA::String_var LogMsg =
 132               CORBA::string_dup(abortMessage.str().c_str());
 133             m_pInterfaceLogger->putMessage(LogMsg);
 134             exit(1);
 135           }
 136         else
 137           {
 138             std::ostringstream aMessage;
 139             aMessage << " " << myTrace.trace;
 140             CORBA::String_var LogMsg =
 141               CORBA::string_dup(aMessage.str().c_str());
 142             m_pInterfaceLogger->putMessage(LogMsg);
 143           }
 144       }
 145     }
 146   pthread_exit(NULL);
 147   return NULL;
 148 }
 149
 150 // ============================================================================
 151 /*!
 152  *  Destructor: wait until printing thread ends (SALOMETraceCollector::run)
 153  */
 154 // ============================================================================
 155
 156 SALOMETraceCollector:: ~SALOMETraceCollector()
 157 {
 158   pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
 159   if (_singleton)
 160     {
 161       DEVTRACE("SALOMETraceCollector:: ~SALOMETraceCollector()");
 162       LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
 163       _threadToClose = 1;
 164       myTraceBuffer->insert(NORMAL_MESS,"end of trace\n"); // to wake up thread
 165       if (_threadId)
 166         {
 167           int ret = pthread_join(*_threadId, NULL);
 168           if (ret) { std::cerr << "error close SALOMETraceCollector : "<< ret << std::endl; }
 169           else { DEVTRACE("SALOMETraceCollector destruction OK") };
 170           delete _threadId;
 171           _threadId = 0;
 172           _threadToClose = 0;
 173         }
 174       _singleton = 0;
 175     }
 176   pthread_mutex_unlock(&_singletonMutex); // release lock
 177 }
 178
 179 // ============================================================================
 180 /*!
 181  * Constructor: no need of LocalTraceBufferPool object initialization here,
 182  * thread safe singleton used in LocalTraceBufferPool::instance()
 183  */
 184 // ============================================================================
 185
 186 SALOMETraceCollector::SALOMETraceCollector()
 187 {
 188   _threadId=0;
 189   _threadToClose = 0;
 190 }
 191
 192 // ============================================================================
 193 /*!
 194  *
 195  */
 196 // ============================================================================
 197
 198 #include "KernelBasis.hxx"
 199 #include "SALOME_Logger_Server.hxx"
 200 #include "SALOME_Fake_NamingService.hxx"
 201
 202 #include <memory>
 203
 204 extern "C"
 205 {
 206  SALOMETRACECOLLECTOR_EXPORT
 207   BaseTraceCollector *SingletonInstance(void)
 208   {
 209     if(getSSLMode())
 210     {
 211       SALOME_Logger::Logger_var logger = KERNEL::getLoggerServantSA();
 212       std::unique_ptr<SALOME_Fake_NamingService> ns(new SALOME_Fake_NamingService);
 213       ns->Register(logger,"/Logger");
 214     }
 215     BaseTraceCollector *instance = SALOMETraceCollector::instance();
 216     return instance;
 217   }
 218 }