ryzom/server/src/patchman_service/log_report.h

   1 // NeLNS - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef NL_LOG_REPORT_H
  18 #define NL_LOG_REPORT_H
  19
  20 #include "nel/misc/types_nl.h"
  21 #include "nel/misc/log.h"
  22 #include "nel/misc/thread.h"
  23 #include <string>
  24 #include <vector>
  25 #include <map>
  26
  27
  28 class CLogReport;
  29
  30 /*
  31  *
  32  */
  33 class CMakeLogTask : public NLMISC::IRunnable
  34 {
  35 public:
  36
  37         /// Constructor
  38         CMakeLogTask() : _Stopping(false), _Complete(false), _Thread(NULL), _OutputLogReport(NULL) {}
  39
  40         /// Destructor
  41         ~CMakeLogTask();
  42
  43         /// Start (called in main thread)
  44         void    start();
  45
  46         /// Ask for stop and wait until terminated (called in main thread)
  47         void    terminateTask();
  48
  49         ///
  50         bool    isRunning() const { return (_Thread != NULL) && (!_Complete); }
  51
  52         ///
  53         bool    isStopping() const { return _Stopping; }
  54
  55         ///
  56         bool    isComplete() const { return _Complete; }
  57
  58         virtual void run();
  59
  60         /// Set the path of logfile directory.
  61         void setLogPath(const std::string & logPath);
  62
  63         /// Set one or more paths of logfile directory. They will be processed when running the background thread.
  64         void setLogPaths(const std::vector<std::string>& logPaths);
  65
  66         /// Set the path of logfile directory to default value
  67         void setLogPathToDefault();
  68
  69         /// Return the log paths
  70         const std::vector<std::string> getLogPaths() const { return _LogPaths; }
  71
  72         /** Set which files are to be browsed:
  73          * v       --> log*.log (default if setLogTarget() not called or called with an empty string)
  74          * v*      --> log*.log + v*_log*.log
  75          * v<n>    --> v<n>_log*.log
  76          * v<n>+   --> v<n>_log*.log + all matching greater <n> + log*.log
  77          * v<n>-   --> v<n>_log*.log + all matching lower <n>
  78          * *       --> *.log
  79          */
  80         void setLogTarget(const std::string & logTarget) { _LogTarget = logTarget; }
  81
  82         /// Return the log report (NULL if task not started yet)
  83         CLogReport*             getLogReport() { return _OutputLogReport; }
  84
  85 private:
  86
  87         void    pleaseStop() { _Stopping = true; }
  88         void    clear();
  89
  90         volatile bool   _Stopping;
  91         volatile bool   _Complete;
  92         std::string             _LogTarget;
  93         std::vector<std::string>        _LogPaths;
  94
  95         NLMISC::IThread *_Thread;
  96
  97         CLogReport              *_OutputLogReport;
  98 };
  99
 100
 101 const uint NB_LINES_PER_PAGE = 100;
 102
 103
 104 /**
 105  *
 106  */
 107 class CLogLineInfo
 108 {
 109 public:
 110
 111         CLogLineInfo() : NbOccurences(0) {}
 112
 113         void                            addAnOccurence( const std::vector<std::string>& lineTokens );
 114
 115         uint                            NbOccurences;
 116
 117         std::string                     SampleLogText;
 118 };
 119
 120
 121 /**
 122  *
 123  */
 124 class ILogReport
 125 {
 126 public:
 127
 128         virtual void storeLine( const std::vector<std::string>& lineTokens, bool mainCountOnly ) = 0;
 129
 130         virtual void report( NLMISC::CLog *targetLog, bool detailed ) = 0;
 131
 132         virtual uint getNbDistinctLines() const = 0;
 133
 134         virtual uint getNbTotalLines( NLMISC::CLog::TLogType logType ) = 0;
 135
 136         virtual ~ILogReport() {}
 137 };
 138
 139
 140 /**
 141  * For one service (service name, not service instance), store info about log lines
 142  */
 143 class CLogReportLeaf : public ILogReport
 144 {
 145 public:
 146
 147         /// Constructor
 148         CLogReportLeaf( const std::string& service ) : _Service(service), _TotalLines(0) {}
 149
 150         std::string             service() { return _Service; }
 151
 152         virtual uint    getNbDistinctLines() const { return (uint)_LogLineInfo.size(); }
 153
 154         virtual uint    getNbTotalLines( NLMISC::CLog::TLogType logType );
 155
 156         virtual void    storeLine( const std::vector<std::string>& lineTokens, bool mainCountOnly );
 157
 158         virtual void    report( NLMISC::CLog *targetLog, bool detailed );
 159
 160         uint                    reportPart( uint beginIndex, uint maxNbLines, NLMISC::CLog *targetLog );
 161
 162 protected:
 163
 164         typedef std::map< std::string, CLogLineInfo > CLogLineInfoMap;
 165
 166         std::string                                             _Service;
 167
 168         CLogLineInfoMap                                 _LogLineInfo;
 169
 170         std::map< std::string, uint >   _Counts; // indexed by log type string
 171
 172         uint                                                    _TotalLines;
 173 };
 174
 175
 176 /**
 177  * Store info about log lines for several services
 178  */
 179 class CLogReportNode : public ILogReport
 180 {
 181 public:
 182
 183         /// Constructor
 184         CLogReportNode() {}
 185
 186         /// Destructor
 187         ~CLogReportNode() { reset(); }
 188
 189         /// Clear all
 190         void    reset()
 191         {
 192                 for ( std::vector<CLogReportLeaf*>::iterator it=_Children.begin(); it!=_Children.end(); ++it )
 193                         delete (*it);
 194                 _Children.clear();
 195         }
 196
 197 protected:
 198
 199         virtual void                            storeLine( const std::vector<std::string>& lineTokens, bool mainCountOnly=false );
 200
 201         CLogReportLeaf*                         getChild( const std::string& service )
 202         {
 203                 for ( std::vector<CLogReportLeaf*>::iterator it=_Children.begin(); it!=_Children.end(); ++it )
 204                 {
 205                         if ( (*it)->service() == service )
 206                                 return (*it);
 207                 }
 208                 return NULL;
 209         }
 210
 211         CLogReportLeaf*                         addChild( const std::string& service )
 212         {
 213                 CLogReportLeaf *child = new CLogReportLeaf( service );
 214                 _Children.push_back( child );
 215                 return child;
 216         }
 217
 218         virtual void    report( NLMISC::CLog *targetLog, bool displayDetailsPerService );
 219
 220         virtual uint    getNbDistinctLines() const
 221         {
 222                 uint n = 0;
 223                 for ( std::vector<CLogReportLeaf*>::const_iterator it=_Children.begin(); it!=_Children.end(); ++it )
 224                         n += (*it)->getNbDistinctLines();
 225                 return n;
 226         }
 227
 228         virtual uint    getNbTotalLines( NLMISC::CLog::TLogType logType=NLMISC::CLog::LOG_UNKNOWN )
 229         {
 230                 uint n = 0;
 231                 for ( std::vector<CLogReportLeaf*>::const_iterator it=_Children.begin(); it!=_Children.end(); ++it )
 232                         n += (*it)->getNbTotalLines( logType );
 233                 return n;
 234         }
 235
 236         void                    reportPage( uint pageNum, NLMISC::CLog *targetLog );
 237
 238 private:
 239
 240         std::vector<CLogReportLeaf*>    _Children;
 241 };
 242
 243
 244 /*
 245  * <Class description>
 246  * \author Olivier Cado
 247  * \author Nevrax France
 248  * \date 2004
 249  */
 250 class CLogReport : public CLogReportNode
 251 {
 252 public:
 253
 254         /// Constructor
 255         CLogReport() : _CurrentFile(~0), _TotalFiles(~0) {}
 256
 257         /// Clear all
 258         void    reset() { CLogReportNode::reset(); }
 259
 260         /**
 261          * Add a log line to the report tree.
 262          * \param onlyType Type of log to study. If LOG_UNKNOWN, study all.
 263          * \param countOtherTypes If true and onlyType not LOG_UNKNOWN, count the number of lines of each other type found.
 264          */
 265         void    pushLine( const std::string& line, NLMISC::CLog::TLogType onlyType=NLMISC::CLog::LOG_WARNING, bool countOtherTypes=true );
 266
 267         /// Set the current progress
 268         void    setProgress( uint currentFile, uint totalFiles ) { _CurrentFile = currentFile; _TotalFiles = totalFiles; }
 269
 270         /// Get the current progress
 271         void    getProgress( uint& currentFile, uint& totalFiles ) { currentFile = _CurrentFile; totalFiles = _TotalFiles; }
 272
 273         /// Get results for a service
 274         void    reportByService( const std::string& service, NLMISC::CLog *targetLog );
 275
 276         /// Get partial results (pageNum>=1)
 277         void    reportPage( uint pageNum, NLMISC::CLog *targetLog ) { CLogReportNode::reportPage( pageNum, targetLog ); }
 278
 279         /// Get summary of results
 280         virtual void report( NLMISC::CLog *targetLog, bool displayDetailsPerService=false ) { CLogReportNode::report( targetLog, displayDetailsPerService ); }
 281
 282 private:
 283
 284         uint    _CurrentFile;
 285         uint    _TotalFiles;
 286 };
 287
 288
 289 #endif // NL_LOG_REPORT_H
 290
 291 /* End of log_report.h */