logger.cpp

来自「2009 ROBOCUP 仿真2DSERVER 源码」· C++ 代码 · 共 1,363 行 · 第 1/3 页

// -*-c++-*-

/***************************************************************************
                                logger.cpp
                         Classes for game logging
                             -------------------
    begin                : 2008-02-15
    copyright            : (C) 2008 by The RoboCup Soccer Simulator
                           Maintenance Group.
    email                : [e-mail]
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LGPL as published by the Free Software  *
 *   Foundation; either version 2 of the License, or (at your option) any  *
 *   later version.                                                        *
 *                                                                         *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "logger.h"

#include "player.h"
#include "clangmsg.h"
#include "coach.h"
#include "field.h"
#include "heteroplayer.h"
#include "monitor.h"
#include "playerparam.h"
#include "serverparam.h"
#include "team.h"
#include "xpmholder.h"

#include "dispsender.h"
#include "initsenderlogger.h"
#include "serializermonitor.h"

#include "serializercommonstdv8.h"

#include <boost/lexical_cast.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>

#include <sstream>

#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif

const std::string Logger::DEF_TEXT_NAME = "incomplete";
const std::string Logger::DEF_TEXT_SUFFIX = ".rcl";
const std::string Logger::DEF_GAME_NAME = "incomplete";
const std::string Logger::DEF_GAME_SUFFIX = ".rcg";
const std::string Logger::DEF_KAWAY_NAME = "incomplete";
const std::string Logger::DEF_KAWAY_SUFFIX = ".kwy";


Logger::Logger( Stadium & stadium )
    : M_init_observer( new rcss::InitObserverLogger )
    , M_observer( new rcss::ObserverLogger )
    , M_stadium( stadium )
    , M_game_log( static_cast< std::ostream * >( 0 ) )
    , M_text_log( static_cast< std::ostream * >( 0 ) )
    , M_playmode( PM_Null )
    , M_team_l_score( 0 )
    , M_team_r_score( 0 )
    , M_team_l_pen_taken( 0 )
    , M_team_r_pen_taken( 0 )
{

}

Logger::~Logger()
{
    this->close();
}

bool
Logger::setSenders()
{
    if ( ! isGameLogOpen() )
    {
        return true;
    }

    int log_version = ServerParam::instance().gameLogVersion();
    int monitor_version = 3;
    switch ( log_version ) {
    case REC_VERSION_5:
        monitor_version = 4;
        break;
    case REC_VERSION_4:
        monitor_version = 3;
        break;
    case REC_VERSION_3:
        monitor_version = 2;
        break;
    case REC_VERSION_2:
    case REC_OLD_VERSION:
        monitor_version = 1;
        break;
    default:
        monitor_version = log_version - 1;
        break;
    }

    rcss::SerializerMonitor::Creator ser_cre;
    if ( ! rcss::SerializerMonitor::factory().getCreator( ser_cre, monitor_version ) )
    {
        return false;
    }

    const rcss::SerializerMonitor * ser = ser_cre();
    if ( ! ser )
    {
        return false;
    }

    //
    // init sender
    //
    {
        rcss::InitSenderLogger::Params init_params( *M_game_log,
                                                    *this,
                                                    *ser,
                                                    M_stadium );
        rcss::InitSenderLogger::Creator init_cre;
        if ( ! rcss::InitSenderLogger::factory().getCreator( init_cre, log_version ) )
        {
            return false;
        }
        M_init_observer->setInitSender( init_cre( init_params ) );
    }

    // disp sender
    {
        rcss::DispSenderLogger::Params disp_params( *M_game_log,
                                                    *this,
                                                    *ser,
                                                    M_stadium );
        rcss::DispSenderLogger::Creator disp_cre;
        if ( ! rcss::DispSenderLogger::factory().getCreator( disp_cre, log_version ) )
        {
            return false;
        }
        M_observer->setDispSender( disp_cre( disp_params ) );
    }

    return true;
}

bool
Logger::open()
{
    if ( ServerParam::instance().gameLogging() )
    {
        if ( ! openGameLog() )
        {
            return false;
        }
    }

    if ( ServerParam::instance().textLogging() )
    {
        if ( ! openTextLog() )
        {
            return false;
        }
    }

    if ( ServerParam::instance().keepAwayMode()
         && ServerParam::instance().kawayLogging() )
    {
        if ( ! openKawayLog() )
        {
            return false;
        }
    }

    return true;
}

void
Logger::close()
{
    renameLogs();

    closeGameLog();
    closeTextLog();
    closeKawayLog();
}

bool
Logger::openGameLog()
{
    boost::filesystem::path dir( ServerParam::instance().gameLogDir(),
                                 boost::filesystem::portable_posix_name );
    if ( ! boost::filesystem::exists( dir )
         && ! boost::filesystem::create_directory( dir ) )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't create game log dir. game_log_dir = ["
                  << ServerParam::instance().gameLogDir() << ']'
                  << std::endl;
        return false;
    }

    M_game_log_name = ServerParam::instance().gameLogDir();
#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32) || defined (__CYGWIN__)
    if ( *M_game_log_name.rbegin() != '\\' )
    {
        M_game_log_name += '\\';
    }
#else
    if ( *M_game_log_name.rbegin() != '/' )
    {
        M_game_log_name += '/';
    }
#endif

    if ( ServerParam::instance().gameLogFixed() )
    {
        M_game_log_name += ServerParam::instance().gameLogFixedName();
    }
    else
    {
        M_game_log_name += Logger::DEF_GAME_NAME;
    }
    M_game_log_name += Logger::DEF_GAME_SUFFIX;

    if ( ServerParam::instance().gameLogCompression() > 0 )
    {
        M_game_log_name += ".gz";
        rcss::gz::gzofstream * f
            = new rcss::gz::gzofstream( M_game_log_name.c_str(),
                                        ServerParam::instance().gameLogCompression() );
        M_game_log = f;
    }
    else
    {
        std::ofstream * f
            = new std::ofstream( M_game_log_name.c_str(),
                                 ( std::ofstream::binary
                                   | std::ofstream::out
                                   | std::ofstream::trunc ) );
        M_game_log = f;
    }

    if ( ! isGameLogOpen() )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't open the game log file " << M_game_log_name << std::endl;
        return false;
    }

    if ( ! setSenders() )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't set senders " << M_game_log_name << std::endl;
        return false;
    }

    M_init_observer->sendHeader();
    M_init_observer->sendServerParams();
    M_init_observer->sendPlayerParams();
    M_init_observer->sendPlayerTypes();
    M_game_log->flush();

    return true;
}

bool
Logger::openTextLog()
{
    boost::filesystem::path dir( ServerParam::instance().textLogDir(),
                                 boost::filesystem::portable_posix_name );
    if ( ! boost::filesystem::exists( dir )
         && ! boost::filesystem::create_directory( dir ) )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't create text log dir. text_log_dir = ["
                  << ServerParam::instance().textLogDir() << ']'
                  << std::endl;
        return false;
    }

    M_text_log_name = ServerParam::instance().textLogDir();
#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32) || defined (__CYGWIN__)
    if ( *M_text_log_name.rbegin() != '\\' )
    {
        M_text_log_name += '\\';
    }
#else
    if ( *M_text_log_name.rbegin() != '/' )
    {
        M_text_log_name += '/';
    }
#endif

    if ( ServerParam::instance().textLogFixed() )
    {
        M_text_log_name += ServerParam::instance().textLogFixedName();
    }
    else
    {
        M_text_log_name += Logger::DEF_TEXT_NAME;
    }
    M_text_log_name += Logger::DEF_TEXT_SUFFIX;

    if ( ServerParam::instance().textLogCompression() > 0 )
    {
        M_text_log_name += std::string ( ".gz" );
        rcss::gz::gzofstream * f
            = new rcss::gz::gzofstream( M_text_log_name.c_str(),
                                        ServerParam::instance().textLogCompression() );
        M_text_log = f;
    }
    else
    {
        std::ofstream * f = new std::ofstream( M_text_log_name.c_str() );
        M_text_log = f;
    }

    if ( ! isTextLogOpen() )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't open the text log file " << M_text_log_name << std::endl;
        return false;
    }

    return true;
}


bool
Logger::openKawayLog()
{
    boost::filesystem::path dir( ServerParam::instance().kawayLogDir(),
                                 boost::filesystem::portable_posix_name );
    if ( ! boost::filesystem::exists( dir )
         && ! boost::filesystem::create_directory( dir ) )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't create keepaway log dir."
                  << std::endl;
        return false;
    }

    M_kaway_log_name = ServerParam::instance().kawayLogDir();
#if defined(_WIN32) || defined(__WIN32__) || defined (WIN32) || defined (__CYGWIN__)
    if ( *M_kaway_log_name.rbegin() != '\\' )
    {
        M_kaway_log_name += '\\';
    }
#else
    if ( *M_kaway_log_name.rbegin() != '/' )
    {
        M_kaway_log_name += '/';
    }
#endif

    if ( ServerParam::instance().kawayLogFixed() )
    {
        M_kaway_log_name += ServerParam::instance().kawayLogFixedName();
    }
    else
    {
        M_kaway_log_name += Logger::DEF_KAWAY_NAME;
    }
    M_kaway_log_name += Logger::DEF_KAWAY_SUFFIX;

    M_kaway_log.open( M_kaway_log_name.c_str() );

    if ( ! M_kaway_log.is_open() )
    {
        std::cerr << __FILE__ << ": " << __LINE__
                  << ": can't open keepaway_log_file " << M_kaway_log_name
                  << std::endl;
        return false;
    }

    return true;
}


void
Logger::closeGameLog()
{
    if ( M_game_log )
    {
        M_game_log->flush();
        delete M_game_log;
        M_game_log =  static_cast< std::ostream * >( 0 );
    }
}

void
Logger::closeTextLog()
{
    if ( M_text_log )
    {
        M_text_log->flush();
        delete M_text_log;
        M_text_log =  static_cast< std::ostream * >( 0 );
    }
}

void
Logger::closeKawayLog()
{
    if ( M_kaway_log.is_open() )
    {
        M_kaway_log.flush();
        M_kaway_log.close();
    }
}

void
Logger::renameLogs()
{
    if ( ! isGameLogOpen()
         && ! isTextLogOpen()
         && ! M_kaway_log.is_open() )
    {
        return;
    }

    // add penalty to logfile when penalties are score or was draw and one team won
    bool bAddPenaltyScore = ( M_stadium.teamRight().point() == M_stadium.teamLeft().point()
                              && M_stadium.teamLeft().penaltyTaken() > 0
                              && M_stadium.teamRight().penaltyTaken() > 0 );

    char time_str[32];
    std::strftime( time_str, 32,
                   ServerParam::instance().logDateFormat().c_str(),
                   &( M_stadium.realTime() ) );

    std::string team_name_score( "" );

    if ( M_stadium.teamLeft().enabled() )
    {
        team_name_score += M_stadium.teamLeft().name();
        team_name_score += "_";