/home/vlg/develop/libASSA/libassa/assa/RemoteLogger.cpp

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                               RemoteLogger.cpp
//------------------------------------------------------------------------------
// $Id: RemoteLogger.cpp,v 1.3 2006/07/26 00:27:32 vlg Exp $
//------------------------------------------------------------------------------
//  Copyright (c) 2003 by Vladislav Grinchenko
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version
//  2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
// Date:
//------------------------------------------------------------------------------

#include <iostream>
#include <sstream>

#include "Reactor.h"
#include "Socket.h"
#include "RemoteLogger.h"

using namespace ASSA;

/*******************************************************************************
 Class member functions
*******************************************************************************/
RemoteLogger::
RemoteLogger () :
    m_state (closed),
    m_recursive_call (false)
{
    // no-op
}

int
RemoteLogger::
open ()
{
    return 0;
}

int 
RemoteLogger::
log_open (const char*  appname_, 
          const char* logfname_, 
          u_long        groups_, 
          u_long       maxsize_,
          Reactor*     reactor_)
{
    if (m_recursive_call) {
        return 0;
    }
    m_recursive_call = true;

    if (m_state == opened) {
        return 0;
    }
    m_logfname = logfname_;
    m_groups   = groups_;
    m_reactor  = reactor_;

    m_reactor->registerIOHandler (this, get_stream ().getHandler(), 
                                  ASSA::READ_EVENT);

    get_stream ().turnOptionOff (Socket::nonblocking);

    size_t len = sizeof (maxsize_) +
        Socket::xdr_length (appname_) +
        Socket::xdr_length (logfname_);

    get_stream () << 1234567890 << SIGN_ON << len
                  << maxsize_ << appname_ << logfname_ << ASSA::flush;
    m_state = opened;
    m_recursive_call = false;
    return 0;
}

int 
RemoteLogger::
log_close (void)
{
    if (m_state == opened) {
        m_recursive_call = true;
        get_stream () << 1234567890 << SIGN_OFF << 0 << ASSA::flush;
        m_reactor->removeHandler (this, READ_EVENT);
        m_recursive_call = false;
    }
    return 0;
}

int 
RemoteLogger::
handle_close (int fd_)
{
    m_state = closed;
    m_logfname.empty ();
    return 0;
}

void 
RemoteLogger::
log_resync (void)
{
    if (m_state == opened) {
        m_recursive_call = true;
        get_stream () << ASSA::flush;
        m_recursive_call = false;
    }
}

int 
RemoteLogger::
log_msg (Group               groups_,
         size_t        indent_level_, 
         const string&    func_name_,
         size_t         expected_sz_,
         const char*            fmt_,
         va_list           msg_list_)
{
    if (m_recursive_call) {
        return 0;
    }
    if (m_state == closed) {
        return -1;
    }
    if (!group_enabled (groups_)) { 
        return 0; 
    }

    std::ostringstream os;
    add_timestamp (os);
    indent_func_name (os, func_name_, indent_level_, FUNC_MSG);

    bool release = false;
    char* msgbuf_ptr = format_msg (expected_sz_, fmt_, msg_list_, release);
    if (msgbuf_ptr == NULL) {
        return -1;              // failed to format
    }

    os << msgbuf_ptr;

    if (release) {
        delete [] msgbuf_ptr;
    }

    if (get_stream ()) {
        m_recursive_call = true;
        Assure_exit (os.str ().length () != 0);
        get_stream () << 1234567890 << LOG_MSG << Socket::xdr_length (os.str ())
                      << os.str () << ASSA::flush;
        m_recursive_call = false;
    }
    else {
        m_state = closed;
    }
    return 0;
}

int 
RemoteLogger::
log_func (Group               groups_, 
          size_t        indent_level_,
          const string&    func_name_, 
          marker_t              type_)
{
    if (m_recursive_call) {
        return 0;
    }
    if (m_state == closed) {
        return -1;
    }
    if (! group_enabled (groups_)) { 
        return 0; 
    }

    std::ostringstream os;
    add_timestamp (os);
    indent_func_name (os, func_name_, indent_level_, type_);
    os << ((type_ == FUNC_ENTRY) ? "---v---\n" : "---^---\n");

    if (get_stream ().good ()) {
        m_recursive_call = true;
        get_stream () << 1234567890 << LOG_MSG << Socket::xdr_length (os.str ())
                      << os.str () << ASSA::flush;
        m_recursive_call = false;
    }
    else {
        m_state = closed;
    }

    return 0;
}

---