---

gitlogger.h

Go to the documentation of this file.

/*
 * Name: filter.m4
 *
 * Description:
 *     DOXYGEN Input file filter for DRAMA source files.
 *
 *     This file must be complatible with both Solaris and GNU m4.  All
 *     unused macros are deleted and this comment must end up as a C/C++
 *     compatible comment which is not picked up by DOXYGEN.
 * 
 * Synopsis:
 *    DCF(func)  => Produces a link to a DRAMA C source file func.html 
 *                   in ../routines.
 *     DDL(link,text) => Produce a link to ../link.html, specified link text.
 *
 * Language: m4 macro. 
 *
 * Author: Tony Farrell, AAO.
 *
 * "@(#) $Id: ACMM:DramaHtml/filter.m4,v 3.24 03-Nov-2009 09:07:29+11 tjf $"
 *
 * History:
 *     10-Nov-2004 - TJF - Original Version.
 */



#ifndef GITLOGGER_INC
#define GITLOGGER_INC
/*+
 *          G I T L O G G E R . H
 *
 *  Function:
 *      Header file for a class which implements Logging.
 *
 *      This file now uses DOXYGEN comments to generate the C++ web pages.
 *      m4 macros of the form @htmlonly <a href="../routines/function.html">function()</a>@endhtmlonly are used in the comments
 *      to refer to DRAMA C function documention (see DramaHtml/Makefile,
 *      DramaHtml/doxygen.config and DramaHtml/filter.m4 for detials)
 *
 *  Description:
 *      
 *
 *  Author(s): Tony Farrell, AAO (TJF)
 *
 *-
 *  History:
 *     30-May-2001 - TJF - Original version
 *     13-Jun-2001 - TJF - Support log directory specification to constructor.
 *     01-Aug-2003 - TJF - Revamp to support all the DRAMA COMMS logs.
 *     14-Aug-2003 - TJF - Support a posix background thread.  Add status
 *                         arguments to sync and semaphore ops.  Add
 *                         ARGS logging level.
 *     09-Jan-2003 - TJF - Add support for DOXYGEN comments.
 *     16-Sep-2004 - TJF - In the VxWorks implementation of GitLogger___Time(),
 *                         the various variables are now static - to ensure all
 *                         tasks int he one machine use the same values.
 *     01-Dec-2004 - TJF - Add support for flushing the log file after every 
 *                         write, variable flushAlways.  Add routines 
 *                         GitLoggerFlushAlways() and GitLoggerFile().
 *     01-Mar-2006 - TJF - Add Log() function which takes a time tag, rather
 *                         then using the current time.  This required 
 *                         changes in LogMessage() and UpdateTime().  
 *                         GetLogger is now a public member static function.
 *     29-Aug-2007 - TJF - Add GitLoggerTune function - allowing us to
 *                         turn flushing, file syncs and background thread.
 *                       Under linux, the fsync mode is turned off by default
 *                         due to performance problems.  GitLoggerTune() can
 *                         turn it back on.
 *                       Posix Thread support now turned back on, but the
 *                         thread must be enabled using GitLoggerTune().  This
 *                         change resulted in some refactoring to allow the
 *                         semaphore to be created all the time, regardless
 *                         of if the posix thread is running.
 *                       Support a file size limit of 1/2Gb - with the file
 *                         re-opened with a different name under these
 *                         conditions.  1/2Gb is well within the normal limit
 *                         of 2Gb - so we don't worry about catching every
 *                         case where it might occur - just the main logging
 *                         entry and file open.
 *    29-Aug-2008 - TJF - Add class variables "failed", "compress" and 
 *                         "fileSize". 
 *                        Add new methods OpenIt(), CheckCompressMode(),
 *                         CloseLogFile(), NewName() and NameUsed().
 *                        Add new argument to GitLogger::GitLogger().
 *
 *
 * @(#) $Id: ACMM:DramaGit/gitlogger.h,v 3.49 17-Sep-2009 14:08:16+10 tjf $
 */
/*
 * This file now uses DOXYGEN comments - the following is placed into the
 * index page.  note that the @file block says to include the typedefs,
 * functions etc from this file into the documentation.
 */

#ifndef VxWorks
/*
 * MacOsX (__APPLE__), Linux and Solaris all have posix threads  We define
 * the GIT_USE_POSIX_THREADS macro for all of these unless GIT_NO_POSIX_THREADS 
 * is defined (allowing an override for older versions if needed).  For
 * other machines, can also define GIT_USE_POSIX_THREADS at compile time, but
 * this must be consistent for all cases where gitlogger.h is used.
 *
 * CURRENTLY I HAVE DISABLED POSIX THREADS IN THE CONSTRUCTOR DUE TO APPARENT 
 * CONFLICT WITH CFITSIO LIBRARY which id don't understand.  TJF 2004. THE
 *  TUNING function can re-enabled it.
 */ 
#if defined(__APPLE__) || defined(__linux__) || defined(solaris2)
#ifndef GIT_NO_POSIX_THREADS
#define GIT_USE_POSIX_THREADS
#endif
#endif
#endif


#include "DitsTypes.h"
#include "Ers.h"
#ifdef VxWorks
#include <semLib.h>
#include <taskLib.h>
#include <errno.h>
#elif defined (GIT_USE_POSIX_THREADS)
#include <signal.h>
#include <semaphore.h>
#include <pthread.h>
#endif



/*
 * Usable log levels.  
 *
 * When a log call is made, if the and of the supplied log level
 * and the currently enabled log level is non-zero, then the message
 * is logged.
 */
#define  LOG_ALL        0xFFFFFFFF  
#define  LOG_STARTUP    0x01        
#define  LOG_ERRORS     0x02        
#define  LOG_ACTENT     0x04        
#define  LOG_ACTEXIT    0x08        
#define  LOG_INST       0x10        
#define  LOG_MSG        0x20        
#define  LOG_DEBUG      0x40        
#define  LOG_COMMS      0x80        
#define  LOG_USER1      0x100       
#define  LOG_USER2      0x200       
#define  LOG_USER3      0x400       
#define  LOG_USER4      0x800       
#define  LOG_ARGS       0x1000      
#define  LOG_ALWAYS     0x40000     
#define  LOG_ALWAYS_S   0x80000     
#ifdef __cplusplus

#include <stdio.h>
#include <string>
#include <DitsFix.h>

/*
 * Declare these here so they can be made friends of GitLogger.
 */ 
extern "C" FILE *GitLoggerFile(StatusType *status);
extern "C" DVOID GitLoggerFlushAlways(int flag, StatusType *status);
extern "C" DVOID GitLoggerTune(unsigned NewSettings, 
                               unsigned *OldSettings, 
                               StatusType *status);



class GitLogger;

/*
 * This object fetches and formats the time.  The UpdateTime() function
 * updates the internal time and TimeToString() returns the formated
 * time string.
 */
class GitLogger___Time {
    
 private:
    /* 
     * We keep about the formated time we last used - to avoid doing it again
     * We also need the time itself - for which we use a "long int" to avoid
     * having to include time.h for this module.
     */
    long int LastTime;
    int millisec;  /*  milliseconds within the second */
    char timeStr[30];
    /* Experimental and debugging value - an offset added to all values
       returned by time();
    */
    static long int timeOffset;
#ifdef VxWorks
    static bool initialised;
    static long int ticksToTime; /* Add this to the number of seconds since
                             system boot to get the current Unix time */
    static long int clockRate;
#endif
 
 public:
    GitLogger___Time();

    /*
     * Readout the current system time and update the internal time string.  If
     * altTime is non-zero, it is a pointer to a time to use instead of the
     * current system time.
     */
    void UpdateTime(GitLogger *logger, StatusType *status, 
                    const IMP_AbsTime *altTime=0);
     
    /*
     * Return the time string.
     */
    const char *TimeString() const { return timeStr; };
    /*
     * Return the milliseconds point within the second.
     */
    int Millisec() const { return millisec; };
    /*
     * Set/Get the current time offset.
     */
    static void SetTimeOffset(long int t) { timeOffset = t; }
    static long int GetTimeOffset() { return timeOffset; }

    
};


class GitLogger {

    friend DVOID GitLoggerFlushAlways(int flag, StatusType *status);
    friend FILE *GitLoggerFile(StatusType *status);
    friend DVOID GitLoggerTune(unsigned NewSettings, 
                               unsigned *OldSettings, 
                               StatusType *status);

 private:
    /*
     * This internal object is used to fetch and format the time.
     */
    GitLogger___Time timer;

    static const int SyncThreadRate = 5;  /* How often in seconds the sync thead
                                      runs */

    /* Structure used to maintain level names */
    typedef struct  { 
        int minsig; unsigned level; const char *string; 
    } LevelStruct;

    /* 
     * We need to define SemType and SemNull for each 
     * architecture.  SemType is the type for a semaphore whilst
     * SemNull is a value which indictes a semaphore is invalid
     * The ControlSem item should be defined here but its definition
     * is always the same ( it just needs to be here so that
     * TakeSem() and GiveSem() can use it.
     *
     * We also need to define TakeSem() and GiveSem() for each
     * architecture.  
     *
     * Additionally, any architecture specific bits should be
     * put here.
     */
#   ifdef VxWorks
        /*
         * VxWorks background thread and sempahore.
         */
        typedef SEM_ID SemType;
        static const SemType  SemNull;
        /*
         * A semaphore used to control access to the log file when
         * we use a background thread to write it.
         */
        SemType ControlSem;
        /*
         * Semaphore control.  Architecture specific.  If the background
         * thread is not supported on an architecutre, then these can
         * be null routines.
         */
        void TakeSem(StatusType *status)  {
            if (*status != STATUS__OK) return;
            if (ControlSem != SemNull)
                semTake(ControlSem, WAIT_FOREVER);
        }
        void GiveSem(StatusType *status) const {
            if (*status != STATUS__OK) ;
            if (ControlSem != SemNull)
                semGive(ControlSem);
        }
        void CreateSem(StatusType *status);
        void DeleteSem();
        int threadID;      /* The background thread VxWorks task id */ 
        int mainTaskID;    /* The main task id */
  public: /* so that SyncThreadStatic can access it */
        void SyncThread(); /* Implementation method for background thread. */
  private:

#   elif defined(GIT_USE_POSIX_THREADS)

        typedef sem_t SemType;    /* The type of a posix semaphore */
        SemType ControlSemX;       /* For sem_init() use  */
        SemType *ControlSemAddr;  /* If using sem_init(), then &ControlSem,
                                     if using sem_open(), return value from
                                     sem_open() */
        bool SemOk;             /* Indicates if the semaphore was created ok*/
        bool SemIsTaken;        /* Indicates if the semaphore is taken */
        bool ThreadOk;          /* Was thread created ok */

        sigset_t origSigMask;  /* Signal mask at point semaphore is taken */

        void TakeSem(StatusType *status) ;
        void GiveSem(StatusType *status) ;
        void CreateSem(StatusType *status);
        void DeleteSem();

        static void UserSignalHandler(int);


        pthread_t syncThreadId;
        pthread_t semThreadId;

        std::string semName;  /* Name if used named semaphore */

      public: /* So that extern "C" linkage statics can access them */
        void SyncThread(); /* Implementation method for background thread. */
        void SyncThreadCleanup();
      private:

#   else
        /* Default values - architectures without a background thread */
        typedef int    SemType;
        static const SemType  SemNull = 0;
        SemType ControlSem;  /* Definition always the same */
        void TakeSem(StatusType *)  { };
        void GiveSem(StatusType *)  { };
        void CreateSem(StatusType *) {};
        void DeleteSem() {};
#   endif


    static const LevelStruct LevelNames[];
    static const char *RescheduleReasons[];
    static const char *Requests[];
    static const char *PathStatus[];
    static const char *MessageTypes[];

    /* Maximum length of messages */
    static const int MsgLen;
    static const char *LogFormat;
    static const char *LogFormatTimed;
    static const char *LogFormatHeader;

    /* Current Logging levels - which goto the file and which to the screen.*/
    unsigned FileLevels;
    unsigned ScreenLevels;

    /* If we true,then logging of MsgOut messages is disabled (since we 
       are using MsgOut to log to screen)
    */
    bool DisableMsgOut;

    /* Log file */
    FILE *LogFile;
    std::string LogFileName;

    /*
     * LastDay contain the day number in the year.  We use it to work
     * out if the day has changed.
     */
    int LastDay;

    /*
     * Directory and system names supplied to constructor.
     */
    std::string directory;
    std::string system;
    /*
     * Set true to always flush the log file.
     */
    bool flushAlways;
    /*
     * Set true to turn of fsync() operation when flusshing
     */
    bool noFsync;
    /*
     * Set true to disable LogFlush()
     */
    bool noLogFlush;
    /*
     * Are we trying to run the sync thread.
     */
    bool syncThreadRun;
    /*
     * Is the sync thread actually running
     */
    bool syncThreadIsRunning;
    /*
     * Set true when the log is flushed, cleared when messages
     * are written.
     */
    bool flushed;

    /*
     * Last write to log file failed.
     */
    bool failed;
    /*
     * Are we compressing data on the fly (posix only)
     */
    bool compress;
    /*
     * This variable records the approimate file size - in particular, the
     * amount of data we have written to the file using GitLogger::LogMessage(), the
     * core logging routine.  It does not record various bits of header information.
     *
     * We use this allow us to create a new log file every 512 MB - to avoid file system
     * file size problems which occur at about 1 GB on older file systems..  
     */
    INT32 fileSize;

    /*
     * Background sync thread initialisation/shutdown.
     */
    void SyncThreadStart(StatusType *status);
    void SyncThreadStop();

    /*
     * Used to actually sync the log file.
     */
    void SyncFile(const char *from_where, StatusType *);
    /*
     * We need a static routine to implement the log level action
     * which can then call the object routine Action.
     */
    static void LogLevelAction(StatusType *status);
    void Action(StatusType *status);

    /*
     * static routines which are passed to DRAMA to implement the
     * DRAMA logging system.  See DitsSetLogSys().
     */
    static DVOID ActionEntryLog(DVOIDP client_data,StatusType *status);
    static DVOID ActionReturnLog(
        DVOIDP client_data,
        int argDelete,
        SdsIdType argOut,
        DitsReqType request,
        int delaySet,
        DCONSTV DitsDeltaTimeType * delay,
        StatusType exitStatus,
        StatusType *status);
    static DVOID GetPathLog(
        DVOIDP client_data,
        DCONSTV  char * name,
        DCONSTV  char * node,
        int flags,
        DCONSTV DVOIDP info,
        DitsPathType path,
        DitsTransIdType transid,
        StatusType *  status);
    static  DVOID MsgSendLog(
        DVOIDP client_data,
        long int flags,
        DitsPathType path,
        DitsTransIdType transid,
        DCONSTV DitsGsokMessageType *  message,
        StatusType *status);
    static DVOID LoadLog(
        DVOIDP client_data,
        DCONSTV char * Machine,
        DCONSTV char * TaskName,
        DCONSTV char * ArgString,
        long int Flags,
        DCONSTV DitsTaskParamType * TaskParams,
        DitsTransIdType transid,
        StatusType *status);
    static  DVOID NotifyReqLog(
        DVOIDP client_data,
        int notifyRequested,
        DitsPathType path,
        DitsTransIdType transid,
        StatusType *status);
    static DVOID MsgOutLog(
        DVOIDP client_data,
        DCONSTV char * message,
        StatusType *status);
    static DVOID LogMsgLog(
        DVOIDP client_data,
        unsigned    level,
        DCONSTV char * prefix,
        DCONSTV char * fmt,
        va_list ap,
        StatusType *status);

    static DVOID LogTrigger(
        DVOIDP client_data,
        SdsIdType arg,
        StatusType *status);    

    static DVOID LogTrigBulk(
        DVOIDP client_data,
        DCONSTV DVOIDP SharedMemInfo,
        int sds,
        int NotifyBytes,
        DitsTransIdType transid,
        StatusType *status);

    static DVOID LogSignal(
        DVOIDP client_data,
        long int actptr,
        DCONSTV DVOIDP ptr,
        SdsIdType arg,
        StatusType *status);    

    static DVOID LogBulkSend(
        DVOIDP client_data,
        DCONSTV long int flags,
        DCONSTV DitsPathType path,
        DCONSTV DVOIDP SharedMemInfo,
        int NotifyBytes,
        DitsTransIdType transid,
        DCONSTV DitsGsokMessageType *  message,
        StatusType * status);  


    static DVOID ErsLog(DVOIDP logArg, DCONSTV ErsMessageType * message,
                       StatusType * status);
    static DVOID LogShutdown(
        DVOIDP client_data,
        int taskShutdown,
        StatusType *status);
        
    static DVOID LogFlush(DVOIDP client_data, StatusType *status);
    static DVOID LogInfo(DVOIDP client_data, StatusType *status);
    
        
    /*
     * The actual routine which logs to the file etc.  If altTime is specified,
     * then the log message is taged with that time, otherwise it is taged
     * with the current time
     */
    void LogMessage(bool logToFile, bool logToScreen, const char *prefix,
                    const char *message, StatusType *status,
                    const IMP_AbsTime *altTime=0);


    /*
     * Function to set the logging levels from a string.
     */
    void SetLevels(const char *s, StatusType *status);
    /* Functions to fetch logging levels. */
    void GetLevels(std::string *s, StatusType *status);
    void GetLevels(int stringLen, char *s, StatusType *status);
    /* Support function for GetLevels */
    void LevelCheckAndAdd(const unsigned index, std::string *const s);

    void OpenLogFile(bool day_rollover, bool size, StatusType *status);
    void OpenIt(const std::string &BaseLogFileName);
    /* Check if the file size has got too large */
    void CheckFileSize(StatusType *status);

    /* Check if we should use compress mode */
    void CheckCompressMode();
    /* Close log file */
    void CloseLogFile();

    /* Create a new log file name */
    static std::string NewName(const std::string &BaseLogFileName, int counter);

    /* Has a log file named already been used */
    static bool NameUsed(const std::string &name);
    /*
     * Assignemnt operation and Copy constructor  made private
     * to avoid misuse.
     */
    void operator=(const GitLogger&);
    GitLogger(const GitLogger&);

    /* Destructor - protected to prevent non-heap objects.  */
 protected:
    ~GitLogger();


 public:

    GitLogger(const char *system, StatusType *status, const char *dir=0, bool compress=false);

    void CheckDayChange(int newDay, StatusType *status);


    static void SetTimeOffset(long int t){GitLogger___Time::SetTimeOffset(t); }
    
    void Log(unsigned level, bool nofmt, const char *prefix,
             StatusType *status, const char *fmt, ...)
#ifdef __GNUC__
        //DOES NOT WORK - WHY      __attribute__ ((format (printf, 5, 6)))
#endif
       ;

    void Log(const IMP_AbsTime *time,
             unsigned level, bool nofmt, const char *prefix,
             StatusType *status, const char *fmt, ...)
#ifdef __GNUC__
        //DOES NOT WORK - WHY      __attribute__ ((format (printf, 5, 6)))
#endif
       ;

    void Set(unsigned newFileLevels, unsigned newScreenLevels, 
             StatusType *status);
      
    void Unset(unsigned newFileLevels, unsigned newScreenLevels, 
             StatusType *status);

    static GitLogger *GetLogger(StatusType * const status);


};
/* Now C level interfaces */
extern "C" {
#endif

    DPUBLIC DVOID GitLoggerInit(const char *system,StatusType *status);
    DPUBLIC FILE *GitLoggerFile(StatusType *status);

    DPUBLIC DVOID GitLoggerFlushAlways(int flag, StatusType *status);


#define GIT_LOGGER_M_NO_FSYNC      1  /* If set, don't fsync on flush */
#define GIT_LOGGER_M_FLUSH_ALWAYS  2  /* If set, flush on each event */
#define GIT_LOGGER_M_LOG_FLUSH_OFF 4  /* If set, don't flush on LogFlush() events,
                                         normally DitsMsgOut events */
#define GIT_LOGGER_M_SYNC_THRD_RUN 8 /* If set - run the sync thread */
#define GIT_LOGGER_M_SYNC_THRD_IS_RNNNG 16 /* Return only - if set - sync 
                                              thread is running */
    DPUBLIC DVOID GitLoggerTune(unsigned NewSettings, 
                                unsigned *OldSettings, 
                                StatusType *status);
#ifdef __cplusplus
}
#endif

#endif

---