StStarLogger/logging/TxEventLog.h

/*
 * @file TxEventLog.h
 * @author Roopa Pundaleeka
 *
 * @(#)cpp/api:$Id: TxEventLog.h,v 1.7 2010/09/17 19:34:54 fine Exp $
 *
 * TxEventLog provides an interface for applications so that they can write
 * event information into a CEDPS formated file.
 */
 
#ifndef TX_EVENT_LOG_H
#define TX_EVENT_LOG_H

#include <string>

#include "TxUCMConstants.h"

namespace TxLogging {
class StUcmTasks;
class StUcmJobs;
class StUcmEvents;
class StRecord;

  class TxEventLog {

  public:
    enum Stage {
      START  = 1,
      STATUS = 2,
      END    = 3
    };

    enum Level {
      LEVEL_UNKNOWN  = 0,
      LEVEL_TRACE    = 1,
      LEVEL_DEBUG    = 2,
      LEVEL_INFO     = 3,
      LEVEL_NOTICE   = 4,
      LEVEL_WARNING  = 5,
      LEVEL_ERROR    = 6,
      LEVEL_CRITICAL = 7,
      LEVEL_ALERT    = 8,
      LEVEL_FATAL    = 9,
      TOTAL_LEVELS
    };

    enum State {
      UNKNOWN        = 0,
      UNSUBMITTED    = 1,
      STAGEIN        = 2,
      PENDING        = 3,
      ACTIVE         = 4,
      SUSPENDED      = 5,
      STAGEOUT       = 6,
      CLEANUP        = 7,
      DONE           = 8,
      FAILED         = 9,
      TOTAL_STATES
    };

protected:
    TxEventLog ();
    virtual void writeDown(const std::string& message)=0;
public:

    virtual ~TxEventLog ();

    virtual void writeDown(const char *message);
    virtual void setEnvBrokerTaskID (const std::string& envBrokerTaskID)=0;
    void setEnvBrokerTaskID (const char *envBrokerTaskID);
    
    virtual void setEnvBrokerJobID (const std::string& envBrokerJobID)=0;
    void setEnvBrokerJobID (const char *envBrokerJobID);
    
    virtual void setBrokerTaskID (const std::string& brokerTaskID)=0;
    void setBrokerTaskID (const char *brokerTaskID);
    
    virtual void setBrokerJobID (int brokerJobID)=0;
    
    virtual void setRequesterName (const std::string& requester)=0;
    void setRequesterName (const char *requester);
    
    virtual void setContext (const std::string& context)=0;
    void setContext (const char *context);

    virtual void logStart (const std::string& key, const std::string& value)=0;
    void logStart (const char *key = TxUCMConstants::appStart,
                   const char *value = "application started");

    virtual void logJobSubmitLocation (const std::string& url)=0;
    void logJobSubmitLocation (const char *url);
    virtual void setJobSubmitLocation (const std::string& url)=0;
    void setJobSubmitLocation (const char *url);

    virtual void logJobAttribute (const std::string& key, const std::string& value)=0;
    void logJobAttribute (const char *key, const char *value);
    virtual void logTask (unsigned int size=1)=0;
    
    virtual void logTask (const std::string& taskAttributes)=0;
    void logTask (const char *taskAttributes);
    virtual void logJobSubmitState (State state)=0;
    virtual void setJobSubmitState (State state)=0;

    virtual void logJobSubmitID (const std::string& ID)=0;
    void logJobSubmitID (const char *ID);
    virtual void setJobSubmitID (const std::string& ID)=0;
    void setJobSubmitID (const char *ID);

    virtual void logEvent (const std::string& logMsg, 
                   Level level = LEVEL_INFO,
                   Stage stage = STATUS, 
                   const std::string& msgContext = TxUCMConstants::defaultContext)=0;
    
    void logEvent (const char *logMsg, 
                   Level level = LEVEL_INFO, 
                   Stage stage = STATUS, 
                   const char *msgContext = TxUCMConstants::defaultContext);
    
    virtual void logEvent (const std::string& userKey, 
                   const std::string& userValue, 
                   Level level = LEVEL_INFO, 
                   Stage stage = STATUS, 
                   const std::string& msgContext = TxUCMConstants::defaultContext)=0;
    void logEvent (const char *userKey, 
                   const char *userValue,
                   Level level = LEVEL_INFO,
                   Stage stage = STATUS, 
                   const char *msgContext = TxUCMConstants::defaultContext);

    virtual void logEnd (const std::string& key, const std::string& value)=0;
    void logEnd (const char *key   = TxUCMConstants::appEnd,
                 const char *value = "application ended");
//_______________________
//    
      virtual  StUcmTasks  *getTaskList ();
      virtual  StUcmTasks  *getTaskList (int limit);
      virtual  StUcmTasks  *getTaskList (int limit, int offset) = 0; 
          
      virtual  StUcmJobs   *getJobList();
      virtual  StUcmJobs   *getJobList(StRecord *task);
      virtual  StUcmJobs   *getJobList(StRecord *task, int limit);
      virtual  StUcmJobs   *getJobList(int limit);
      virtual  StUcmJobs   *getJobList(int limit, int offset);
      virtual  StUcmJobs   *getJobList(StRecord *task, int limit, int offset)=0;
      virtual  int          getJobId(const char *requester, const char *taskBrokerId, int jobBrokerId) = 0; 

      virtual  StUcmEvents *getEventList();
      virtual  StUcmEvents *getEventList(StRecord *job);
      virtual  StUcmEvents *getEventList(StRecord *job,int limit);
      virtual  StUcmEvents *getEventList(int limit);
      virtual  StUcmEvents *getEventList(int limit, int offset);
      virtual  StUcmEvents *getEventList(StRecord *job,int limit, int offset)=0;

      virtual  int  queryTableSize(const char *tableName);
      virtual  int  queryTableSize(const char *tableName, const char *where)=0;
      virtual  int  queryTableSize(const char *tableName, const StRecord   *where)=0;

    /* The current Db for the last selected job
     *       
     * @param int dbJobID, value of Job ID
     *
     */
     virtual void setDbJobID (int dbJobID)=0;
  };
}
#ifndef TXEVENT_DEFAULT_IMPLEMENTAION
#define TXEVENT_DEFAULT_IMPLEMENTAION(classname)       \
 StUcmTasks  *classname::getTaskList ()                \
 { return TxEventLog::getTaskList() ; }                \
 StUcmTasks  *classname::getTaskList (int limit)       \
 { return TxEventLog::getTaskList(limit); }            \
 StUcmJobs  *classname::getJobList ()                  \
 { return TxEventLog::getJobList() ; }                 \
 StUcmJobs  *classname::getJobList (StRecord *task)    \
 { return TxEventLog::getJobList(task) ; }             \
 StUcmJobs  *classname::getJobList (int limit)         \
 { return TxEventLog::getJobList(limit); }             \
 StUcmJobs  *classname::getJobList (StRecord *task,int limit) \
 { return TxEventLog::getJobList(task,limit); }        \
 StUcmJobs  *classname::getJobList (int limit,int offset)     \
 { return TxEventLog::getJobList(limit,offset); }    \
 StUcmEvents  *classname::getEventList ()              \
 { return TxEventLog::getEventList() ; }               \
 StUcmEvents  *classname::getEventList (StRecord *job) \
 { return TxEventLog::getEventList(job) ; }            \
 StUcmEvents  *classname::getEventList (int limit)     \
 { return TxEventLog::getEventList(limit); }           \
 StUcmEvents  *classname::getEventList (StRecord *job,int limit) \
 { return TxEventLog::getEventList(job,limit); }       \
 StUcmEvents  *classname::getEventList (int limit,int offset)    \
 { return TxEventLog::getEventList(limit,offset); }    \
 int classname::queryTableSize (const char *table_name)\
 { return TxEventLog::queryTableSize(table_name); }    \
 void classname::writeDown(const char *message)        \
 { return TxEventLog::writeDown(message); } 

#define TXEVENT_DEFAULT_IMPLEMENTAION_2(classname)            \
 int classname::getJobId (const char *requester, const char *taskBrokerId, int jobBrokerId)\
 {  assert(0 && "getJobId has not been implemented yet");     \
    return 0; }                                               \
 StUcmTasks  *classname::getTaskList (int limit, int offset)  \
 {  assert(0 && "getTaskList has not been implemented yet");  \
    return 0; }                                               \
 StUcmJobs  *classname::getJobList (StRecord *task,int limit, int offset)                 \
 { assert(0 && task && limit && offset &&  "getJobList has not been implemented yet");    \
    return 0; }                                               \
 StUcmEvents  *classname::getEventList (StRecord *job,int limit, int offset)              \
 { assert(0 && job && limit && offset&& "getEventList has not been implemented yet");     \
    return 0; }                                               \
 int classname::queryTableSize (const char *table_name, const char *where)                \
 { assert(0 && table_name && where && "queryTableSize has not been implemented yet");     \
   return 0; }                                                \
 int classname::queryTableSize (const char *table_name, const StRecord *where)            \
 { assert(0 && table_name && where && "queryTableSize has not been implemented yet");     \
   return 0; }                                                \
 void classname::setDbJobID (int bJobID)                      \
 { assert(0 && bJobID && "setDbJobID has not been implemented yet"); }
#endif
#endif

---