loggingserver.h

Go to the documentation of this file.

#ifndef LOGGINGSERVER_H_
#define LOGGINGSERVER_H_

#include <QMutexLocker>
#include <QSocketNotifier>
#include <QMutex>
#include <QQueue>
#include <QElapsedTimer>

#include <cstdint>
#include <ctime>
#include <unistd.h>

#include "mythconfig.h"
#include "mythbaseexp.h"  //  MBASE_PUBLIC , etc.
#include "verbosedefs.h"
#include "mythsignalingtimer.h"
#include "mthread.h"

#define LOGLINE_MAX (2048-120)

class QString;
class MSqlQuery;
class LoggingItem;

class LoggerBase : public QObject
{
    Q_OBJECT

  public:
    explicit LoggerBase(const char *string);
    ~LoggerBase() override;
    virtual bool logmsg(LoggingItem *item) = 0;
    virtual void reopen(void) = 0;
    virtual void stopDatabaseAccess(void) { }
  protected:
    char *m_handle {nullptr}; 
};

class FileLogger : public LoggerBase
{
    Q_OBJECT

  public:
    explicit FileLogger(const char *filename);
    ~FileLogger() override;
    bool logmsg(LoggingItem *item) override; // LoggerBase
    void reopen(void) override; // LoggerBase
    static FileLogger *create(const QString& filename, QMutex *mutex);
  private:
    bool m_opened {false}; 
    int  m_fd     {-1};    
};

class SyslogLogger : public LoggerBase
{
    Q_OBJECT

  public:
    SyslogLogger();
    explicit SyslogLogger(bool open);
    ~SyslogLogger() override;
    bool logmsg(LoggingItem *item) override; // LoggerBase
    void reopen(void) override { }; // LoggerBase
    static SyslogLogger *create(QMutex *mutex, bool open = true);
  private:
    bool m_opened {false};  
};

#if CONFIG_SYSTEMD_JOURNAL
class JournalLogger : public LoggerBase
{
    Q_OBJECT

  public:
    JournalLogger();
    ~JournalLogger() override;
    bool logmsg(LoggingItem *item) override; // LoggerBase
    void reopen(void) override { }; // LoggerBase
    static JournalLogger *create(QMutex *mutex);
};
#endif

class DBLoggerThread;

class DatabaseLogger : public LoggerBase
{
    Q_OBJECT

    friend class DBLoggerThread;
  public:
    explicit DatabaseLogger(const char *table);
    ~DatabaseLogger() override;
    bool logmsg(LoggingItem *item) override; // LoggerBase
    void reopen(void) override { }; // LoggerBase
    void stopDatabaseAccess(void) override; // LoggerBase
    static DatabaseLogger *create(const QString& table, QMutex *mutex);
  protected:
    bool logqmsg(MSqlQuery &query, LoggingItem *item);
    void prepare(MSqlQuery &query);
  private:
    bool isDatabaseReady(void);
    static bool tableExists(const QString &table);

    DBLoggerThread *m_thread;   
    QString m_query;            
    bool m_opened             {true};  
    bool m_loggingTableExists {false}; 
    QElapsedTimer m_disabledTime;       
    QElapsedTimer m_errorLoggingTime;   
    static const int kMinDisabledTime; 
};

using LogMessage = QList<QByteArray>;
using LogMessageList = QList<LogMessage *>;

class LogForwardThread : public QObject, public MThread
{
    Q_OBJECT

    friend void logSigHup(void);
  public:
    LogForwardThread();
    ~LogForwardThread() override;
    void run(void) override; // MThread
    void stop(void);
  private:
    bool m_aborted {false};          

    static void forwardMessage(LogMessage *msg);
  signals:
    void incomingSigHup(void);
  protected slots:
    static void handleSigHup(void);
};

MBASE_PUBLIC bool logForwardStart(void);
MBASE_PUBLIC void logForwardStop(void);
MBASE_PUBLIC void logForwardMessage(const QList<QByteArray> &msg);


class QWaitCondition;
#define MAX_QUEUE_LEN 1000

class DBLoggerThread : public MThread
{
  public:
    explicit DBLoggerThread(DatabaseLogger *logger);
    ~DBLoggerThread() override;
    DBLoggerThread(const DBLoggerThread &) = delete;            // not copyable
    DBLoggerThread &operator=(const DBLoggerThread &) = delete; // not copyable

    void run(void) override; // MThread
    void stop(void);
    bool enqueue(LoggingItem *item);

    bool queueFull(void)
    {
        QMutexLocker qLock(&m_queueMutex);
        return (m_queue->size() >= MAX_QUEUE_LEN);
    }
  private:
    DatabaseLogger *m_logger {nullptr};
    QMutex m_queueMutex;               
    QQueue<LoggingItem *> *m_queue {nullptr}; 
    QWaitCondition *m_wait {nullptr};  
    volatile bool m_aborted {false};   
};

#ifndef _WIN32
MBASE_PUBLIC void logSigHup(void);
#endif

#endif

/*
 * vim:ts=4:sw=4:ai:et:si:sts=4
 */