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

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                             Logger.cpp
//------------------------------------------------------------------------------
// $Id: Logger.cpp,v 1.7 2006/07/20 02:30:54 vlg Exp $
//------------------------------------------------------------------------------
//  Copyright (c) 2001,2005 by Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------

#include <stdarg.h>

#include <iostream>             // for WIN32 hacking

#include "assa/Connector.h"
#include "assa/INETAddress.h"
#include "assa/IPv4Socket.h"
#include "assa/FileLogger.h"
#include "assa/StdOutLogger.h"
#include "assa/RemoteLogger.h"
#include "assa/AutoPtr.h"
#include "assa/Logger.h"

using namespace ASSA;

ASSA_DECL_SINGLETON(Logger);

// Internal storage
static const int TMPBUF_SZ = 4096;

// Logger's member functions

int 
Logger::
log_close (void)
{
    int ret = 0;

    if (m_impl) {
        ret = m_impl->log_close ();
        delete m_impl;
        m_impl = 0;
    }
    return ret;
}

int 
Logger::
log_open (u_long groups_)
{
    if (m_impl != NULL) {
        std::cerr << "Logger::log_open - Implementation already exist" 
                  << std::endl;
        return -1;
    }
    m_impl = new StdOutLogger;
    return m_impl->log_open (groups_);
}
    
int 
Logger::
log_open (const char* logfname_, u_long groups_, u_long maxsize_)
{
    if (m_impl != NULL) {
        return -1;
    }
    m_impl = new FileLogger;
    return m_impl->log_open (logfname_, groups_, maxsize_);
}

int 
Logger::
log_open (const std::string& logsvraddr_,
          const char*          logfname_, 
          u_long                 groups_, 
          u_long                maxsize_,
          Reactor*              reactor_)
{
    {
        TimeVal tv (10.0);
        INETAddress addr (logsvraddr_.c_str ());
        if (addr.bad ()) {
            return -1;
        }

        Connector <RemoteLogger, IPv4Socket> log_connector;
        AutoPtr<RemoteLogger> lsp (new RemoteLogger);
        log_connector.open (tv);

        if (log_connector.connect (lsp.get (), addr) < 0) {
            delete m_impl;
            m_impl = NULL;
            return -1;
        }

        m_impl = lsp.release ();
    }
    int ret =  m_impl->log_open (m_app_name.c_str (), logfname_, 
                                 groups_, maxsize_, reactor_);
    return ret;
}

int
Logger::
log_msg (u_long g_, const char* fmt_, ...)
{
    va_list ap;
    va_list ap2;
    string  empty_str;
    size_t  expected_sz = 0;

    static char tmpbuf[TMPBUF_SZ];
    char*   bufp = tmpbuf;
    int     len = TMPBUF_SZ;
    int     ret;

    if (m_impl == NULL) {
        return -1;
    }

#if defined(WIN32)

    va_copy (ap2, ap);
    ret = vsnprintf (bufp, len-1, fmt_, ap2);
    va_end (ap2);

    if (ret == -1 || ret >= len) 
    {
        len *= 2;
        bufp = new char [len];
        while (1) {
            va_copy (ap2, ap);
            ret = vsnprintf (bufp, len-1, fmt_, ap2);
            va_end (ap2);
            if (ret > -1 && ret < len) {
                delete [] bufp;
                break;
            }
            len *= 2;
            delete [] bufp;
            bufp = new char [len];
//          std::cout << "Logger::log_func : malloc(" << len << ")\n"
//                    << std::flush;
        }
    }

#else /* POSIX, C99 compliant */

    char c;
    va_start (ap, fmt_);
    ret = ::vsnprintf (&c, 1, fmt_, ap);
    va_end (ap);

#endif

    expected_sz = ret + 1;

//  std::cout << "Logger::log_func : expected_sz = " 
//            << expected_sz << "\n" << std::flush;

    va_start (ap, fmt_);
    ret = m_impl->log_msg (static_cast<Group> (g_), 
                           m_context.size (),
                           m_context.size () ? m_context.top () : empty_str,
                           expected_sz, 
                           fmt_, 
                           ap);
    va_end (ap);

    return ret;
}

int
Logger::
log_func (u_long g_, marker_t type_)
{
    std::string empty_str;

    if (m_impl == NULL) {
        return -1;
    }

    return  m_impl->log_func (static_cast<Group> (g_), 
                              m_context.size (),
                              m_context.size () ? m_context.top () : empty_str,
                              type_);
}

---