S3FC project page

S3FC home page

---

               

---

s3_logger.h

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#ifndef S3_LOGGER__H
#define S3_LOGGER__H

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>
#include <list>
#include <iomanip>
#include <syslog.h>
#include <s3fc/s3_message.h>
#include <s3fc/s3_exception.h>
#include <s3fc/s3_thread_base.h>
#include <s3fc/s3_conversion.h>
#include <s3fc/s3_mutex.h>


#define S3_LOG_DEFAULT_IDENT   "s3_log"

#define S3_DEFAULT_OSTREAM_BUF_SIZE 1024
//------------------------------------------------------------------------------
class s3_file_buffer : public std::filebuf 
{
public:
   
   s3_file_buffer( const std::string& filename, bool append = true ) 
      throw( s3_generic_exception )
   {
      if ( std::filebuf::open(
         filename.c_str(),
         append ? (std::ios::app | std::ios::out) :
         (std::ios::out) ) == 0) 
      {
         throw s3_generic_exception( "s3_file_buffer::s3_file_buffer()", 
                                     "file open error" );
      }
   }

   virtual ~s3_file_buffer() {}
};

//------------------------------------------------------------------------------
class s3_generic_streambuf : public std::streambuf
{
private:

   std::vector<char> putbuffer;

   virtual void write_to_device() = 0;

public:
   
   s3_generic_streambuf( const unsigned int put_buffer_len = 
                         S3_DEFAULT_OSTREAM_BUF_SIZE ) :
      putbuffer( put_buffer_len + 1 )
   {
      setp( &putbuffer[0], &putbuffer[put_buffer_len] );   
   }

   virtual ~s3_generic_streambuf() 
   {
      // We may not sync() here because this will indirectly do a call
      // to s3_generic_streambuf::write_to_device() (which is pure virtual).
      // This is very much not a good thing to do.
      // This implies that the destructors of the derived classes MUST call
      // sync().
   }

   virtual int overflow( int ch )
   {
      sync();
      if ( ch != EOF )
      {
         *pptr() = static_cast<char>( ch );
         pbump( 1 );
      }
      return ch;
   }

   virtual int sync( void )
   {
      if ( pptr() > pbase() )
      {
         *pptr() = static_cast<char>('\0');
         write_to_device();
         setp( &putbuffer[0], &putbuffer[putbuffer.size()] );   
      }
      return 0;
   }
};

//------------------------------------------------------------------------------
class s3_syslog_buffer : public s3_generic_streambuf
{
private:

   std::string remainder_string;

   virtual void write_to_device()
   {
      // We want to do a call to syslog everytime there is a '\n'
      // character.
      std::string pbase_str( pbase() );
      std::string::size_type start_i = 0;
      std::string::size_type idx;

      while ( ( idx = pbase_str.find( "\n", start_i ) ) != std::string::npos )
      {
         syslog( LOG_ERR, (remainder_string + pbase_str.substr( start_i, idx - start_i )).c_str() );
         start_i = idx + 1;
         remainder_string = "";
      }
      remainder_string = remainder_string +
         pbase_str.substr( start_i, pbase_str.length() - start_i );
   }

public:
   
   s3_syslog_buffer( const unsigned int put_buffer_len = 
                     S3_DEFAULT_OSTREAM_BUF_SIZE ) :
      s3_generic_streambuf( put_buffer_len ),
      remainder_string( "" ) {}

   virtual ~s3_syslog_buffer() 
   {
      sync(); 
   }
};

//------------------------------------------------------------------------------
class s3_syslogger : public std::ostream 
{
 protected:
   
   s3_syslog_buffer logbuf;

 public:

    s3_syslogger() :
       std::ostream( &logbuf ), 
       logbuf() {}

    virtual ~s3_syslogger() {}
};

//------------------------------------------------------------------------------
class s3_msgb_log_buffer : public s3_generic_streambuf
{
private:
   
   virtual void write_to_device()
   {
      msg_box.send_msg( dest_box_name, std::string( pbase() ) );
   }

   s3_message_box msg_box;

   const std::string dest_box_name;

public:
   
   s3_msgb_log_buffer( const std::string &my_box_name,
                       const std::string &dst_box_name,
                       const std::string po_ip = "",
                       const unsigned int po_port = 0 ) :
      msg_box(),
      dest_box_name( dst_box_name )
   {
      if ( ( po_ip != "" ) && ( po_port !=0 ) )
      {
         if ( s3_message_box::initialised() == false )
         {
            s3_message_box::init( po_ip, po_port );
         }
      }

      unsigned int try_cnt = 0;
      while ( true )
      {
         try
         {
            msg_box.set_name( my_box_name + "_" + 
                              s3_conversion::to_string( try_cnt ) );
            msg_box.connect();
            break;
         }
         catch ( s3_generic_exception e )
         {
            if ( std::string( e.what() ).
                 find( "Name clash" ) != std::string::npos )
            {
               try_cnt++;
            }
            else
            {
               throw e;
            }
         }
      }
   }

   virtual ~s3_msgb_log_buffer() 
   {
      msg_box.disconnect();
      sync();
   }
};

//------------------------------------------------------------------------------
class s3_msgb_logger : public std::ostream 
{
 protected:
   
   s3_msgb_log_buffer logbuf;

 public:

    s3_msgb_logger( const std::string &my_box_name,
                    const std::string &dst_box_name,
                    const std::string po_ip = "",
                    const unsigned int po_port = 0 ) :
       std::ostream( &logbuf ), 
       logbuf( my_box_name, dst_box_name, po_ip, po_port ) {}
};

//------------------------------------------------------------------------------
class s3_filelogger : public std::ostream 
{
 private:
   
    s3_file_buffer logbuf;

 public:

    s3_filelogger( const std::string& filename,
                   const bool append = true ) :
       std::ostream( &logbuf ), 
       logbuf( filename, append ) {}
};

//------------------------------------------------------------------------------
class s3_log_buffer : 
   public s3_generic_streambuf, 
   public std::list<std::ostream*> 
{
private:

   std::string ident;

   int priority;

   std::string priority_str;

   s3_mutex write_lock;

   virtual void write_to_device()
   {
      write_lock.lock();

      // Distribute to all registered ostreams.
      for ( std::list<std::ostream*>::iterator it = begin(); 
           it != end(); it++ )
      {
         **it << ident << priority_str << pbase();
      }

      write_lock.unlock();
   }

   bool b_append_info;

public:
   
   s3_log_buffer( const std::string ident_arg,
                  std::ostream *def_out = 0,
                  const bool b_append_info_arg = true ) :
      ident( ident_arg ),
      b_append_info( b_append_info_arg )
   {
      if ( def_out == 0 )
      {
         push_back( &std::cerr );
      }
      else
      {
         push_back( def_out );
      }

      s3_log_buffer::set_priority( LOG_ERR );

      set_ident( ident_arg );
   }

   virtual ~s3_log_buffer() 
   {
      sync();
   }

   void set_ident( const std::string &new_ident )
   {
      if ( ! b_append_info )
      {
         ident = "";
         return;
      }
      ident =  new_ident;
   }

   int get_priority( void )
   {
      return priority;
   }

   void set_priority( const int new_priority )
   {

      if ( ! b_append_info )
      {
         priority_str = "";
         return;
      }

      switch( new_priority )
      {
      case LOG_EMERG:
         priority = new_priority;
         priority_str = " [emergency] ";
         break;
      case LOG_ALERT:
         priority = new_priority;
         priority_str = " [alert] ";
         break;
      case LOG_CRIT:
         priority = new_priority;
         priority_str = " [critical] ";
         break;
      case LOG_ERR:
         priority = new_priority;
         priority_str = " [error] ";
         break;
      case LOG_WARNING:
         priority = new_priority;
         priority_str = " [warning] ";
         break;
      case LOG_NOTICE:
         priority = new_priority;
         priority_str = " [notice] ";
         break;
      case LOG_INFO:
         priority = new_priority;
         priority_str = " [info] ";
         break;
      case LOG_DEBUG:
         priority = new_priority;
         priority_str = " [debug] ";
         break;
      }
   }
}; 


class s3_logger;

template<class TP> class s3_smanip; // TP = Type Param
 
template<class TP>
inline std::ostream& operator<<( s3_logger& o, const s3_smanip<TP>& m )
{
   return m._f( o, m._a );
}
 
template<class TP> 
class s3_smanip 
{
    std::ostream& (*_f)( s3_logger&, TP );
    TP _a;
public:
    s3_smanip( std::ostream& (*f)(s3_logger&, TP), TP a ) : 
       _f( f ), 
       _a( a ) {}
    //
   friend
   std::ostream& operator<< <TP>( s3_logger& o, const s3_smanip<TP>& m );
};

//------------------------------------------------------------------------------
class s3_logger : public std::ostream 
{
 private:

   s3_log_buffer logbuf;   

 public:

    s3_logger( const std::string& ident_arg = S3_LOG_DEFAULT_IDENT,
               std::ostream *def_out = 0,
               const bool b_append_info_arg = true ) : 
       std::ostream( &logbuf ),
       logbuf( ident_arg, def_out, b_append_info_arg ) {}

    s3_logger(const bool b_append_info_arg) : 
       std::ostream( &logbuf ),
       logbuf( S3_LOG_DEFAULT_IDENT, 0, b_append_info_arg ) {}


    ~s3_logger() {}

    std::list<std::ostream*> &ostream_list( void )
    {
       return logbuf;
    }

    std::ostream& setident( const std::string &new_ident )
    {
       logbuf.set_ident( new_ident );
       return *this;
    }

    std::ostream& setpriority( const int new_priority )
    {
       logbuf.set_priority( new_priority );
       return *this;
    }

    int getpriority( void )
    {
       return logbuf.get_priority();
    }
};

inline extern std::ostream& __iomanip_setpriority ( s3_logger& s, int n )
{
   return s.setpriority( n );
}

inline s3_smanip<int> setpriority( int n )           
{ 
   return s3_smanip<int>( __iomanip_setpriority, n ); 
}

inline extern std::ostream& __iomanip_setident ( s3_logger& s, std::string n )
{
   return s.setident( n );
}

inline s3_smanip<std::string> setident( std::string n )           
{ 
   return s3_smanip<std::string>( __iomanip_setident, n ); 
}

//------------------------------------------------------------------------------
class s3_msgb_log_rx_thread : public s3_thread_base
{
protected:
  
   s3_message_box msg_box;

   std::ostream *ostr;

public:

   s3_msgb_log_rx_thread( const std::string &my_box_name,
                          std::ostream *ostream_arg = 0,
                          const std::string &po_ip = "",
                          const unsigned int po_port = 0 ) :
      msg_box( my_box_name )
   {
      if ( ostream_arg == 0 )
      {
         ostr = &std::cerr;
      }
      else
      {
         ostr = ostream_arg;
      }

      if ( ( po_ip != "" ) && ( po_port !=0 ) )
      {
         if ( s3_message_box::initialised() == false )
         {
            s3_message_box::init( po_ip, po_port );
         }
      }
      msg_box.connect();
      msg_box.subscribe_arrival( state_changed );
   }
       
   virtual ~s3_msgb_log_rx_thread() 
   {
      msg_box.disconnect();
   }

   void main_loop()
   {
      // The main while loop will exit when this flag is set to true.   
      bool b_terminate = false;
      while ( b_terminate == false )
      { 
         test_cancel();
         wait_on_state_changed();

         // Check msg_box for any messages.
         s3_message msg = msg_box.get_msg();
         if ( msg.is_empty() == false )
         {
            if ( ostr)
            {
               *ostr << msg.get_body() << std::flush;
            }
         }
      }
   }
};

extern s3_logger s3_log;

#endif // S3_LOGGER__H

---

Send comments to: s3fc@stonethree.com