src/Logger.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2005-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 //
   6 // Any parts of this program derived from the xMule, lMule or eMule project,
   7 // or contributed by third-party developers are copyrighted by their
   8 // respective authors.
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  23 //
  24
  25 #ifndef LOGGER_H
  26 #define LOGGER_H
  27
  28 #include <wx/log.h>
  29 #include <wx/event.h>
  30 #include <iosfwd>
  31
  32
  33 enum DebugType
  34 {
  35         //! Standard warning, not debug
  36         logStandard = -1,
  37         //! General warnings/errors.
  38         logGeneral = 0,
  39         //! Warnings/Errors for the main hashing thread.
  40         logHasher,
  41         //! Warnings/Errors for client-objects.
  42         logClient,
  43         //! Warnings/Errors for the local client protocol.
  44         logLocalClient,
  45         //! Warnings/Errors for the remote client protocol.
  46         logRemoteClient,
  47         //! Warnings/Errors when parsing packets.
  48         logPacketErrors,
  49         //! Warnings/Errors for the CFile class.
  50         logCFile,
  51         //! Warnings/Errors related to reading/writing files.
  52         logFileIO,
  53         //! Warnings/Errors when using the zLib library.
  54         logZLib,
  55         //! Warnings/Errors for the AICH-syncronization thread.
  56         logAICHThread,
  57         //! Warnings/Errors for transfering AICH hash-sets.
  58         logAICHTransfer,
  59         //! Warnings/Errors when recovering with AICH.
  60         logAICHRecovery,
  61         //! Warnings/Errors for the CListenSocket class.
  62         logListenSocket,
  63         //! Warnings/Errors for Client-Credits.
  64         logCredits,
  65         //! Warnings/Errors for the client UDP socket.
  66         logClientUDP,
  67         //! Warnings/Errors for the download-queue.
  68         logDownloadQueue,
  69         //! Warnings/Errors for the IP-Filter.
  70         logIPFilter,
  71         //! Warnings/Errors for known-files.
  72         logKnownFiles,
  73         //! Warnings/Errors for part-files.
  74         logPartFile,
  75         //! Warnings/Errors for SHA-hashset creation.
  76         logSHAHashSet,
  77         //! Warnings/Errors for servers, server connections.
  78         logServer,
  79         //! Warnings/Errors for proxy.
  80         logProxy,
  81         //! Warnings/Errors related to searching.
  82         logSearch,
  83         //! Warnings/Errors related to the server UDP socket.
  84         logServerUDP,
  85         //! Warning/Errors related to Kademlia UDP comunication on client
  86         logClientKadUDP,
  87         //! Warning/Errors related to Kademlia Search
  88         logKadSearch,
  89         //! Warning/Errors related to Kademlia Routing
  90         logKadRouting,
  91         //! Warning/Errors related to Kademlia Indexing
  92         logKadIndex,
  93         //! Warning/Errors related to Kademlia Main Thread
  94         logKadMain,
  95         //! Warning/Errors related to Kademlia Preferences
  96         logKadPrefs,
  97         //! Warnings/Errors related to partfile importer
  98         logPfConvert,
  99         //! Warnings/Errors related to the basic UDP socket-class.
 100         logMuleUDP,
 101         //! Warnings/Errors related to the thread-scheduler.
 102         logThreads,
 103         //! Warnings/Errors related to the Universal Plug and Play subsystem.
 104         logUPnP,
 105         //! Warnings/Errors related to the UDP Firewall Tester
 106         logKadUdpFwTester,
 107         //! Warnings/Errors related to Kad packet tracking.
 108         logKadPacketTracking,
 109         //! Warnings/Errors related to Kad entry tracking.
 110         logKadEntryTracking
 111         // IMPORTANT NOTE: when you add values to this enum, update the g_debugcats
 112         // array in Logger.cpp!
 113 };
 114
 115
 116
 117 /**
 118  * Container-class for the debugging categories.
 119  */
 120 class CDebugCategory
 121 {
 122 public:
 123         /**
 124          * Constructor.
 125          *
 126          * @param type The actual debug-category type.
 127          * @param name The user-readable name.
 128          */
 129         CDebugCategory( DebugType type, const wxString& name );
 130
 131
 132         /**
 133          * Returns true if the category is enabled.
 134          */
 135         bool IsEnabled() const;
 136
 137         /**
 138          * Enables/Disables the category.
 139          */
 140         void SetEnabled( bool );
 141
 142
 143         /**
 144          * Returns the user-readable name.
 145          */
 146         const wxString& GetName() const;
 147
 148         /**
 149          * Returns the actual type.
 150          */
 151         DebugType GetType() const;
 152
 153 private:
 154         //! The user-readable name.
 155         wxString        m_name;
 156         //! The actual type.
 157         DebugType       m_type;
 158         //! Whenever or not the category is enabled.
 159         bool            m_enabled;
 160 };
 161
 162
 163 /**
 164  * Functions for logging operations.
 165  */
 166 class CLogger: public wxEvtHandler
 167 {
 168 public:
 169         /**
 170          * Returns true if debug-messages should be generated for a specific category.
 171          */
 172         bool IsEnabled( DebugType );
 173
 174         /**
 175          * Enables or disables debug-messages for a specific category.
 176          */
 177         void SetEnabled( DebugType type, bool enabled );
 178
 179         /**
 180          * Returns true if logging to stdout is enabled
 181          */
 182         bool IsEnabledStdoutLog();
 183
 184         /**
 185          * Enables or disables logging to stdout.
 186          */
 187         void SetEnabledStdoutLog(bool enabled);
 188
 189
 190         /**
 191          * Logs the specified line of text, prefixed with the name of the DebugType.
 192          * (except for logStandard)
 193          *
 194          * @param file
 195          * @param line
 196          * @param critical If true, then the message will be made visible directly to the user.
 197          * @param type The debug-category, the name of which will be prepended to the line.
 198          * @param str The actual line of text.
 199          *
 200          * This function is thread-safe. If it is called by the main thread, the
 201          * event will be sent directly to the application, otherwise it will be
 202          * queued in the event-loop.
 203          */
 204         void AddLogLine(
 205                 const wxString &file,
 206                 int line,
 207                 bool critical,
 208                 DebugType type,
 209                 const wxString &str,
 210                 bool toStdout = false);
 211
 212         // for UPnP
 213         void AddLogLine(
 214                 const wxString &file,
 215                 int line,
 216                 bool critical,
 217                 DebugType type,
 218                 const std::ostringstream &msg);
 219
 220         void AddLogLine(
 221                 const wxString &file,
 222                 int line,
 223                 bool critical,
 224                 const std::ostringstream &msg);
 225
 226
 227         /**
 228          * Returns a category specified by index.
 229          */
 230         const CDebugCategory&   GetDebugCategory( int index );
 231
 232         /**
 233          * Returns the number of debug-categories.
 234          */
 235         unsigned int GetDebugCategoryCount();
 236
 237         /**
 238          * Open Logfile, true on success
 239          */
 240         bool OpenLogfile(const wxString & name);
 241
 242         /**
 243          * Close Logfile
 244          */
 245         void CloseLogfile();
 246
 247         /**
 248          * Get name of Logfile
 249          */
 250         const wxString & GetLogfileName() const {
 251                 return m_LogfileName;
 252         }
 253
 254         /**
 255          * Event handler
 256          */
 257         void OnLoggingEvent(class CLoggingEvent& evt);
 258
 259         /**
 260          * Construct
 261          */
 262         CLogger() {
 263                 applog = NULL;
 264                 m_StdoutLog = false;
 265                 m_count = 0;
 266         }
 267
 268 private:
 269         class wxFFileOutputStream* applog;      // the logfile
 270         wxString m_LogfileName;
 271         wxString m_ApplogBuf;
 272         bool m_StdoutLog;
 273         int  m_count;                   // output line counter
 274
 275         /**
 276          * Write all waiting log info to the logfile
 277          */
 278         void FlushApplog();
 279
 280         /**
 281          * Really output a single line
 282          */
 283         void DoLine(const wxString & line, bool toStdout);
 284
 285         DECLARE_EVENT_TABLE()
 286 };
 287
 288 extern CLogger theLogger;
 289
 290 /**
 291  * This class forwards log-lines from wxWidgets to CLogger.
 292  */
 293 class CLoggerTarget : public wxLog
 294 {
 295 public:
 296         CLoggerTarget();
 297
 298         /**
 299          * @see wxLog::DoLogString
 300          */
 301         void DoLogString(const wxChar *msg, time_t);
 302 };
 303
 304
 305 DECLARE_LOCAL_EVENT_TYPE(MULE_EVT_LOGLINE, -1)
 306
 307
 308 /** This event is sent when a log-line is queued. */
 309 class CLoggingEvent : public wxEvent
 310 {
 311 public:
 312         CLoggingEvent(bool critical, bool toStdout, const wxString& msg)
 313                 : wxEvent(-1, MULE_EVT_LOGLINE)
 314                 , m_critical(critical)
 315                 , m_stdout(toStdout)
 316                 // Deep copy, to avoid thread-unsafe reference counting. */
 317                 , m_msg(msg.c_str(), msg.Length())
 318         {
 319         }
 320
 321         const wxString& Message() const {
 322                 return m_msg;
 323         }
 324
 325         bool IsCritical() const {
 326                 return m_critical;
 327         }
 328
 329         bool ToStdout() const {
 330                 return m_stdout;
 331         }
 332
 333         wxEvent* Clone() const {
 334                 return new CLoggingEvent(m_critical, m_stdout, m_msg);
 335         }
 336
 337 private:
 338         bool            m_critical;
 339         bool            m_stdout;
 340         wxString        m_msg;
 341 };
 342
 343
 344 typedef void (wxEvtHandler::*MuleLogEventFunction)(CLoggingEvent&);
 345
 346 //! Event-handler for completed hashings of new shared files and partfiles.
 347 #define EVT_MULE_LOGGING(func) \
 348         DECLARE_EVENT_TABLE_ENTRY(MULE_EVT_LOGLINE, -1, -1, \
 349         (wxObjectEventFunction) (wxEventFunction) \
 350         wxStaticCastEvent(MuleLogEventFunction, &func), (wxObject*) NULL),
 351
 352
 353 // access the logfile for EC
 354 class CLoggerAccess
 355 {
 356 private:
 357         class wxFFileInputStream * m_logfile;
 358         class wxCharBuffer * m_buffer;
 359         size_t m_bufferlen;
 360         size_t m_pos;
 361
 362         bool m_ready;
 363 public:
 364         //
 365         // construct/destruct
 366         //
 367         CLoggerAccess();
 368         ~CLoggerAccess();
 369         //
 370         // get a String (if there is one)
 371         //
 372         bool GetString(wxString & s);
 373         //
 374         // is a String available ?
 375         //
 376         bool HasString();
 377 };
 378
 379
 380 /**
 381  * These macros should be used when logging. The
 382  * AddLogLineM macro will simply call one of the
 383  * two CLogger::AddLogLine functions depending on
 384  * parameters, but AddDebugLogLineM will only log
 385  * a message if the message is either critical or
 386  * the specified debug-type is enabled in the
 387  * preferences.
 388  * AddLogLineMS will also always print to stdout.
 389  */
 390 #if defined(MULEUNIT)
 391         #define AddDebugLogLineM(...) do {} while (false)
 392         #define AddLogLineM(...) do {} while (false)
 393         #define AddLogLineMS(...) do {} while (false)
 394         #define AddDebugLogLineN(...) do {} while (false)
 395         #define AddLogLineN(...) do {} while (false)
 396         #define AddLogLineNS(...) do {} while (false)
 397         #define AddDebugLogLineC(...) do {} while (false)
 398         #define AddLogLineC(...) do {} while (false)
 399         #define AddLogLineCS(...) do {} while (false)
 400 #else
 401 // Macros passing critical flag (legacy)
 402         #define AddDebugLogLineM(critical, type, string) theLogger.AddLogLine(__TFILE__, __LINE__, critical, type, string)
 403         #define AddLogLineM(critical, string) theLogger.AddLogLine(__TFILE__, __LINE__, critical, logStandard, string)
 404         #define AddLogLineMS(critical, string) theLogger.AddLogLine(__TFILE__, __LINE__, critical, logStandard, string, true)
 405 // Macro for UPnP. This is not a debug macro, but wants its category printed nevertheless (sigh).
 406         #define AddLogLineU(critical, type, string) theLogger.AddLogLine(__TFILE__, __LINE__, critical, type, string)
 407 // Macros for 'N'on critical logging
 408         #define AddDebugLogLineN(type, string) theLogger.AddLogLine(__TFILE__, __LINE__, false, type, string)
 409         #define AddLogLineN(string) theLogger.AddLogLine(__TFILE__, __LINE__, false, logStandard, string)
 410         #define AddLogLineNS(string) theLogger.AddLogLine(__TFILE__, __LINE__, false, logStandard, string, true)
 411 // Macros for 'C'ritical logging
 412         #define AddDebugLogLineC(type, string) theLogger.AddLogLine(__TFILE__, __LINE__, true, type, string)
 413         #define AddLogLineC(string) theLogger.AddLogLine(__TFILE__, __LINE__, true, logStandard, string)
 414         #define AddLogLineCS(string) theLogger.AddLogLine(__TFILE__, __LINE__, true, logStandard, string, true)
 415 #endif
 416
 417 #endif
 418 // File_checked_for_headers