warlogengine.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarLogEngine.h"   // class implemented

#ifndef WAR_AUTO_LOCK_H
#   include "WarAutoLock.h"
#endif

#ifndef WAR_LOG_H
#   include "WarLog.h"
#endif

using namespace std;

#define AUTO_LOCK WarAutoLock MyLock(mLock);

/////////////////////////////// PUBLIC ///////////////////////////////////////

WarLogEngine* WarLogEngine::mpMe;

//============================= LIFECYCLE ====================================

WarLogEngine::WarLogEngine()
  throw(WarException)
{
    if (mpMe)
        WarThrow(WarError(WAR_ERR_ALREADY_INITIALIZED), NULL);

    mpMe = this;
}// WarLogEngine


WarLogEngine::~WarLogEngine()
{
    if (mpMe == this)
        mpMe = NULL;
}// ~WarLogEngine


//============================= OPERATORS ====================================
//============================= OPERATIONS ===================================

void WarLogEngine::LogEvent(WarLogEvent* plogEvent)
{
    war_logevent_ptr_t event(plogEvent);
    
    if (mLogThreadPtr && mLogThreadPtr->IsActive())
        mLogThreadPtr->PushEvent(event);
    else
        OnLogEvent(event);
}

void WarLogEngine::StartDelayedLogging()
{
    {
        AUTO_LOCK;
        
        if (mLogThreadPtr)
            return;
        
        mLogThreadPtr = new WarLogThread;
    }

    mLogThreadPtr->Open();
    mLogThreadPtr->SetPriority(WAR_THRD_PRI_LOW);
}

void WarLogEngine::SetRelaxMode(war_ccstr_t name, 
                           war_uint32_t mode,
                           bool doRelax) 
                           throw(WarException)
{
    AUTO_LOCK

    WarLogEventHandler *phandler = FindHandler(name);
    if (doRelax)
        phandler->SetSupressFlags(phandler->GetSupressFlags() | mode);
    else
        phandler->SetSupressFlags(phandler->GetSupressFlags() & ~mode);
}

void WarLogEngine::InstallHandler(WarLogEventHandler *pHandler) 
    throw(WarException)
{
    AUTO_LOCK

    WarPtrWrapper<WarLogEventHandler> my_wrapper(pHandler); // Deletes the object if the installation fails

    WarLogEventHandler *phandler = NULL;
    try
    {
        phandler = FindHandler(pHandler->GetName());
    }
    catch(WarException& ex)
    {
        if (ex == WAR_ERR_OBJECT_NOT_FOUND)
        {
            msHandlers.push_back(pHandler);
            RecalcEventsInUse();
            return;
        }

        throw ex;
    }

    WarThrow(WarError(WAR_ERR_OBJECT_EXIST), NULL);
}

void WarLogEngine::RemoveHandler(war_ccstr_t name) 
    throw(WarException)
{
    AUTO_LOCK

    LogHandlerList::iterator P = FindHandlerIterator(name);
    
    msHandlers.erase(P);
    RecalcEventsInUse();
}

void WarLogEngine::EnableEvent(war_ccstr_t handlerName,
                 WarLogEventTypeE eventType, 
                 bool doEnable)
                 throw(WarException)
{   
    WarLogEventHandler *plog_handler = FindHandler(handlerName);

    war_uint32_t mask = plog_handler->GetEventMask();
    WARLOG_SET(mask, eventType, doEnable);
    plog_handler->SetEventMask(mask);
    RecalcEventsInUse();
}

void WarLogEngine::EnableEvent(war_ccstr_t handlerName,
                               war_ccstr_t eventString, 
                               bool doEnable)
                               throw(WarException)
{
    string buffer = eventString;
    for(char *p = strtok(&buffer[0], "; \t")
        ; p
        ; p = strtok(NULL, "; \t"))
    {
        WarLogEventTypeE event = WarLog::Lookup(p);
        if (event != WARLOG_INVALID)
            EnableEvent(handlerName, event, doEnable);
    }
}

//============================= ACESS      ===================================
//============================= INQUIRY    ===================================

const war_ccstr_t WarLogEngine::msEventNames[WARLOG_INVALID +1] = 
{
    {"WARLOG_DEBUG"},
    {"WARLOG_ERROR"},
    {"WARLOG_FILEACC"},
    {"WARLOG_INOUT"},
    {"WARLOG_SECURITY"},
    {"WARLOG_WARNINGS"},
    {"WARLOG_SYSTEM"},
    {"WARLOG_SOCKET"},
    {"WARLOG_SNDFILE"},
    {"WARLOG_RCVFILE"},
    {"WARLOG_CREDIR"},
    {"WARLOG_DELDIR"},
    {"WARLOG_DELFILE"},
    {"WARLOG_LOGIN"},
    {"WARLOG_LOGOUT"},
    {"WARLOG_CREACC"},
    {"WARLOG_DELACC"},
    {"WARLOG_CHGACC"},
    {"WARLOG_CPS"},
    {"WARLOG_INFO"},
    {"WARLOG_THREADS"},
    {"WARLOG_FILES"},
    {"WARLOG_NETWORK"},
    {"WARLOG_INVALID"}
};

std::string WarLogEngine::Explain()
{
    WarCollector<char> out;
    

    out << "Log modules: " 
        << war_endl;

    for(LogHandlerList::iterator P = msHandlers.begin()
        ; P != msHandlers.end()
        ; ++P)
    {
        WarLogEventHandler& my_handler = *(*P);

        out << " --> "
            << my_handler.GetName()
            << " {";

        war_uint32_t mask = my_handler.GetEventMask();

        for(int index = 0; index < WARLOG_INVALID; index++)
        {
            if (WARLOG_ISSET(mask, index))
                out << msEventNames[index] << ' ';
        }

        out << '}'
            << war_endl;
    }


    return out.GetValue();
}

/////////////////////////////// PROTECTED  ///////////////////////////////////

void WarLogEngine::OnLogEvent(war_logevent_ptr_t& logEventPtr)
{
    AUTO_LOCK

    for(LogHandlerList::iterator P = msHandlers.begin()
        ; P != msHandlers.end()
        ; ++P)
    {
        WarLogEventHandler& my_handler = *(*P);
        if (WARLOG_ISSET(my_handler.GetEventMask(), logEventPtr->mType))
        {
            my_handler.OnEvent(*logEventPtr);
        }
    }
}

/////////////////////////////// PRIVATE    ///////////////////////////////////

WarLogEventHandler *WarLogEngine::FindHandler(war_ccstr_t name) 
    throw(WarException)
{
    return &(*(*FindHandlerIterator(name)));
}

WarLogEngine::LogHandlerList::iterator 
WarLogEngine::FindHandlerIterator(war_ccstr_t name) 
    throw(WarException)
{
    if (!name || !*name)
        WarThrow(WarError(WAR_ERR_INVALID_ARGUMENT), NULL);
    
    for(LogHandlerList::iterator P = msHandlers.begin()
        ; P != msHandlers.end()
        ; ++P)
    {
        if ((*P)->operator == (name))
            return P;
    }
    
    WarThrow(WarError(WAR_ERR_OBJECT_NOT_FOUND), NULL);
}

void WarLogEngine::RecalcEventsInUse()
{
    msActiveEvents = 0;

    for(LogHandlerList::iterator P = msHandlers.begin()
        ; P != msHandlers.end()
        ; ++P)
    {
        msActiveEvents |= (*P)->GetEventMask();
    }
}