TxUCMCollector.h

#ifndef STAR_TxUCMCollector
#define STAR_TxUCMCollector
/*
 * UCM Collector
 *
 */
/*****************************************************************
 * @file TxUCMCollector.h
 * @author Roopa Pundaleeka
 *
 * @(#)cpp/api:$Id: TxUCMCollector.h,v 1.8 2010/09/17 19:34:54 fine Exp $
 *
 * Please see TxUCMCollector.h for more documentation.
 * "Translated" from the original TxUCMCOllector.java version 
 */

#include <map>
#include <string>
#include "mysql.h"
#include <log4cxx/logger.h>

#include "StDbFieldI.h"
#include "TxEventLog.h"

typedef bool boolean;
typedef std::string Options;

namespace TxLogging {

class StRecord;
class StUcmTask;
class StUcmTasks;
class StUcmJobs;
class StUcmEvents;
class FieldList;
class RecordList;

class TxUCMCollector : public TxEventLog{ 

    public:
       TxUCMCollector ();
       virtual ~TxUCMCollector ();
    
   boolean initDb ();
    private:
           boolean init ();
    boolean loadDatabase();
    MYSQL *getConnection();
    MYSQL *getConnection (const char *dbUrl,const char *dbUsername
      , const char *dbPassword);
    MYSQL *getConnection (const std::string &dbUrl,const std::string &dbUsername
      , const std::string &dbPassword); 
    unsigned int execute(const std::string &sql);
    unsigned int execute(const char   *sql);
                        virtual void closeConnection();    
    public:
        void startProcess ();
    private:
      void setCurrLogFile ();
    void processLogFile ();
    public:
       void processMessage (const std::string &message);
       void processMessage (const char *message);
      virtual  StUcmTasks  *getTaskList ();
      virtual  StUcmTasks  *getTaskList (int limit);
      virtual  StUcmTasks  *getTaskList (int limit, int offset); 
          
      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);
      virtual  int          getJobId(const char * reqName, const char *taskBrokerId, int jobBrokerId);

      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);

      int fillTaskList(StUcmTasks &tasks,int limit=0, int offset=0);
      int fillJobList(StUcmJobs &jobs,int limit=0, int offset=0);
      int fillJobList(StUcmJobs &jobs,int limit, int offset,const StRecord *task);
      int fillEventList(StUcmEvents &event,int limit=0, int offset=0,const StRecord *job=0);
      void fillFields(FieldList &fields);
      int  fillUcmList(const char *type,RecordList &records, int limit=0, int offset=0);
      int  queryTableSize(const char *tableName);
      int  queryTableSize(const char *tableName, const char *where);
      int  queryTableSize(const char *tableName, const StRecord *where);
      void queryTable(const char *tableName,int limit=0, int offset=0, const char *where=0);
      void queryTaskTable(int limit=0, int offset=0);
      void queryJobTable(int limit=0, int offset=0);
      void queryJobTable(const char *taskID,int limit=0, int offset=0);
      void queryEventTable(int limit=0, int offset=0);
      void queryEventTable(const char *jobID,int limit=0, int offset=0);

    private:
      StDbFieldI *createField(unsigned int fieldIndx);
      static StDbFieldI::EDataType MapSqlField(enum_field_types type);
      void createNewTask ();
      std::string tableNamePrefix(const char *)  const;
      std::string jobTableName() const;
      std::string eventTableName() const;
      void  setBrokerJobID(const StRecord *job);
      void  setBrokerTaskID(const StRecord *job);
     void updateTask ();
     void addJob ();
     void updateJob ();
     void setJobsField (const std::string &fieldName);
     void setJobsField (const char * fieldName);
     void addEvent ();
    void createJobsTable ();
     void createEventsTable ();
     
     void insertRecord (const char * insertStr, const char * tableName);
     void insertRecord (const std::string&insertStr, const std::string&tableName);
     void updateRecord (const char * updateStr, const char * tableName, const char * condition);
     void updateRecord (const std::string&updateStr, const std::string&tableName, const std::string&condition);
     boolean recordExists (const char * selectStr, const char * tableName);
     boolean recordExists (const std::string&selectStr, const std::string&tableName);
     void createTable (const char * table, const char *like=0);
     void createTable (const std::string &table, const std::string &like=std::string());
     static void usage (Options options);
     void printVersion();

    public:
     static void main(const char *args[]);
    private:
    static const char*fgTs;
    static const char*fgEvent;
    static const char*fgBJobID;
    static const char*fgBTaskID;
    static const char*fgRequester;
    static const char*fgContext;
    static const char*fgLevel;
    static const char*fgStage;
    static const char*fgKey;
    static const char*fgValue;

    static const char*fgNewTask;
    static const char*fgUpdateTask;
    static const char*fgAddJob;
    static const char*fgUpdateJob;
    static const char*fgSiteLocation;
    static const char*fgStateID;
    static const char*fgGridJobID;
    static const char*fgAppStart;
    static const char*fgAppEnd;

    static const char*fgStatusFile;
    static const char*fgStatusFileName;
    static const char*fgStatusFileModTime;
    static const char*fgStatusFilePos;

    
    // Class logger
    private:
      log4cxx::LoggerPtr  log;

    // global connection for updating UCMDB
       MYSQL *connection;
       MYSQL_RES   *fResult;
       MYSQL_FIELD *fField;
       MYSQL_ROW   fRow;
       
       bool fIsConnectionOpen;
    // db info
       std::string dbName;
       std::string dbUrl;
       std::string dbUsername;
       std::string dbPassword;

    // logs dir as set by user to read log files from
       std::string logsDir;

    // sleep time as set by user (default = 10 seconds)
       long sleepTime;

    // current log file thats being processed
       const char * currLogFile;
    
    // current position in the log file thats being processed
       long currLogFilePos;
    
    // hash map to hold key value pairs from a message
       std::map<std::string,std::string> msgHashMap;
        // Current broker Job ID to query
        int fBrokerJobID;
        // Current Job Db ID to query
        int fDbJobID;

    // Task table column names
       static const char * fgTaskCols;

    // Jobs table columns
       static const char *fgJobsTableCols;

    // Jobs table column names
   static const char * fgJobCols;


    // Events table columns
   static const char * fgEventsTableCols;

    // Events table column names
   static const char * fgEventCols;
   
// TxEventLog interface
protected:
    virtual void writeDown(const std::string& message);
    virtual void writeDown(const char *message);
public:
//___________________________________________________________________________________________________
    virtual void setEnvBrokerTaskID (const std::string& envBrokerTaskID);
    
   virtual void setEnvBrokerJobID (const std::string& envBrokerJobID);
    
    virtual void setBrokerTaskID (const std::string& brokerTaskID);
    
   virtual void setBrokerJobID (int brokerJobID);
   virtual void setDbJobID (int dbJobID);
    
    virtual void setRequesterName (const std::string& requester);
    
    virtual void setContext (const std::string& context);

    virtual void logStart (const std::string& key, const std::string& value);

     virtual void logJobAttribute (const std::string& key, const std::string& value);
    virtual void logJobSubmitLocation (const std::string& url);
    virtual void setJobSubmitLocation (const std::string& url);

    virtual void logTask (unsigned int size=1);
    
    virtual void logTask (const std::string& taskAttributes);
    virtual void logJobSubmitState (State state);
    virtual void setJobSubmitState (State state);

    virtual void logJobSubmitID (const std::string& ID);
    virtual void setJobSubmitID (const std::string& ID);

    virtual void logEvent (const std::string& logMsg, 
         Level level = LEVEL_INFO,
         Stage stage = STATUS, 
         const std::string& 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);

    virtual void logEnd (const std::string& key, const std::string& value);
  
};
}

#endif