history.h File Reference

#include <string>
#include <vector>
#include "midas.h"

Include dependency graph for history.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	MidasHistoryBufferInterface
class	MidasHistoryBinnedBuffer
class	MidasHistoryInterface

Macros
#define	HS_GET_READER   1
#define	HS_GET_WRITER   2
#define	HS_GET_INACTIVE   4
#define	HS_GET_DEFAULT   8

Functions
MidasHistoryInterface *	MakeMidasHistory ()
MidasHistoryInterface *	MakeMidasHistoryODBC ()
MidasHistoryInterface *	MakeMidasHistorySqlite ()
MidasHistoryInterface *	MakeMidasHistorySqlDebug ()
MidasHistoryInterface *	MakeMidasHistoryMysql ()
MidasHistoryInterface *	MakeMidasHistoryPgsql ()
MidasHistoryInterface *	MakeMidasHistoryFile ()
int	hs_get_history (HNDLE hDB, HNDLE hKey, int flags, int debug_flag, MidasHistoryInterface **mh)
int	hs_find_reader_channel (HNDLE hDB, HNDLE *hKey, int debug_flag)
int	hs_save_event_list (const std::vector< std::string > *pevents)
int	hs_read_event_list (std::vector< std::string > *pevents)
int	hs_define_panel (const char *group, const char *panel, const std::vector< std::string > vars)
INT	hs_define_panel2 (const char *group, const char *panel, const std::vector< std::string > var, const std::vector< std::string > label, const std::vector< std::string > formula={}, const std::vector< std::string > color={})

Macro Definition Documentation

HS_GET_DEFAULT

#define HS_GET_DEFAULT   8

Definition at line 38 of file history.h.

HS_GET_INACTIVE

#define HS_GET_INACTIVE   4

Definition at line 37 of file history.h.

HS_GET_READER

#define HS_GET_READER   1

Definition at line 35 of file history.h.

HS_GET_WRITER

#define HS_GET_WRITER   2

Definition at line 36 of file history.h.

Function Documentation

hs_find_reader_channel()

int hs_find_reader_channel	(	HNDLE	hDB,
		HNDLE *	hKey,
		int	debug_flag
	)

Definition at line 337 of file history_common.cxx.

{
   int status;
   int size;
   HNDLE hKeyChan;
   HNDLE hKey;
   std::string hschanname;
 
   *hKeyOut = 0;
 
   status = db_find_key(hDB, 0, "/Logger/History", &hKeyChan);
   if (status != DB_SUCCESS) {
      cm_msg(MERROR, "hs_find_reader_channel", "Cannot find /Logger/History, db_find_key() status %d", status);
      return status;
   }
 
   // get history channel name selected by user in ODB
 
   status = db_get_value_string(hDB, 0, "/History/LoggerHistoryChannel", 0, &hschanname, TRUE);
   assert(status == DB_SUCCESS);
 
   if (hschanname.length() > 0) {
      status = db_find_key(hDB, hKeyChan, hschanname.c_str(), &hKey);
      if (status == DB_NO_KEY) {
         cm_msg(MERROR, "hs_find_reader_channel", "Misconfigured history: history channel name in /History/LoggerHistoryChannel is \'%s\', not present in /Logger/History, db_find_key() status %d", hschanname.c_str(), status);
         return HS_FILE_ERROR;
      }
      assert(status == DB_SUCCESS);
      *hKeyOut = hKey;
      return HS_SUCCESS;
   }
 
   //  if selected channel name is blank, find first active channel
   
   for (int ichan=0; ; ichan++) {
      status = db_enum_key(hDB, hKeyChan, ichan, &hKey);
      if (status != DB_SUCCESS)
         break;
      
      int active = 0;
      size = sizeof(active);
      status = db_get_value(hDB, hKey, "Active", &active, &size, TID_BOOL, FALSE);
      if (status == DB_SUCCESS && active != 0) {
         *hKeyOut = hKey;
         return HS_SUCCESS;
      }
   }
   
   cm_msg(MERROR, "hs_find_reader_channel", "Cannot find default history: /History/LoggerHistoryChannel is empty and there are no active history channels in /Logger/History");
   return HS_FILE_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_get_history()

int hs_get_history	(	HNDLE	hDB,
		HNDLE	hKey,
		int	flags,
		int	debug_flag,
		MidasHistoryInterface **	mh
	)

Definition at line 22 of file history_common.cxx.

{
   int status, size;
   std::string type;
   int active;
   int debug;
   KEY key;
 
   *mh = NULL;
 
   if (!hKey || (flags&HS_GET_DEFAULT)) {
      status = hs_find_reader_channel(hDB, &hKey, debug_flag);
      if (status != HS_SUCCESS)
         return status;
   }
 
   status = db_get_key(hDB, hKey, &key);
   assert(status == DB_SUCCESS);
 
   if (strcasecmp(key.name, "image") == 0) {
      if (debug_flag)
         cm_msg(MINFO, "hs_get_history", "History channel \'IMAGE\' handled by image facility");
      return DB_NO_KEY;
   }
 
   active = 0;
   size = sizeof(active);
   status = db_get_value(hDB, hKey, "Active", &active, &size, TID_BOOL, TRUE);
   assert(status == DB_SUCCESS);
   
   status = db_get_value_string(hDB, hKey, "Type", 0, &type, TRUE);
   assert(status == DB_SUCCESS);
   
   debug = 0;
   size = sizeof(debug);
   status = db_get_value(hDB, hKey, "Debug", &debug, &size, TID_INT, TRUE);
   assert(status == DB_SUCCESS);
 
   if (debug_flag)
      printf("hs_get_history: see channel hkey %d, name \'%s\', active %d, type [%s], debug %d\n", hKey, key.name, active, type.c_str(), debug);
 
   if (strcasecmp(type.c_str(), "MIDAS")==0) {
 
      std::string tmp;
      // create ODB "History dir"
      db_get_value_string(hDB, hKey, "History dir", 0, &tmp, TRUE);
 
      std::string path = cm_get_history_path(key.name);
 
      int i;
      
      i = 1;
      size = sizeof(i);
      status = db_get_value(hDB, 0, "/Logger/WriteFileHistory", &i, &size, TID_BOOL, FALSE);
      if (status==DB_SUCCESS) {
         cm_msg(MERROR, "hs_get_history", "mlogger ODB setting /Logger/WriteFileHistory is obsolete, please delete it. Use /Logger/History/MIDAS/Active instead");
         if (i==0)
            active = 0;
      }
      
      if (active || (flags & HS_GET_INACTIVE)) {
         *mh = MakeMidasHistory();
         assert(*mh);
         
         (*mh)->hs_set_debug(debug);
         
         status = (*mh)->hs_connect(path.c_str());
         if (status != HS_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "Cannot connect to MIDAS history, status %d", status);
            return status;
         }
 
         if (debug_flag)
            cm_msg(MINFO, "hs_get_history", "Connected history channel \'%s\' type MIDAS history in \"%s\"", key.name, path.c_str());
      }
      
   } else if (strcasecmp(type.c_str(), "ODBC")==0) {
 
      if (1) {
         int i;
      
         i = 0;
         size = sizeof(i);
         status = db_get_value(hDB, 0, "/Logger/ODBC_Debug", &i, &size, TID_INT, FALSE);
         if (status==DB_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "mlogger ODB setting /Logger/ODBC_Debug is obsolete, please delete it. Use /Logger/History/ODBC/Debug instead");
         }
 
         status = db_get_value(hDB, 0, "/History/ODBC_Debug", &i, &size, TID_INT, FALSE);
         if (status==DB_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "mhttpd ODB setting /History/ODBC_Debug is obsolete, please delete it. Use /Logger/History/ODBC/Debug instead");
         }
      
         std::string dsn;
      
         status = db_get_value_string(hDB, 0, "/Logger/ODBC_DSN", 0, &dsn, FALSE);
         if (status==DB_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "mlogger ODB setting /Logger/ODBC_DSN is obsolete, please delete it. Use /Logger/History/ODBC/Writer_ODBC_DSN instead");
         }
 
         status = db_get_value_string(hDB, 0, "/History/ODBC_DSN", 0, &dsn, FALSE);
         if (status==DB_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "mhttpd ODB setting /History/ODBC_DSN is obsolete, please delete it. Use /Logger/History/ODBC/Reader_ODBC_DSN instead");
         }
      }
 
      std::string writer_dsn = "history_writer";
      std::string reader_dsn = "history_reader";
      
      status = db_get_value_string(hDB, hKey, "Writer_ODBC_DSN", 0, &writer_dsn, TRUE);
      assert(status == DB_SUCCESS);
 
      status = db_get_value_string(hDB, hKey, "Reader_ODBC_DSN", 0, &reader_dsn, TRUE);
      assert(status == DB_SUCCESS);
      
      std::string dsn;
 
      if (flags & HS_GET_READER)
         dsn = reader_dsn;
      else if (flags & HS_GET_WRITER)
         dsn = writer_dsn;
      
      if (active || (flags & HS_GET_INACTIVE)) {
         if (debug == 2) {
            *mh = MakeMidasHistorySqlDebug();
         } else if (dsn.length() > 1) {
            *mh = MakeMidasHistoryODBC();
         }
 
         if (*mh == NULL)
            return HS_FILE_ERROR;
         
         (*mh)->hs_set_debug(debug);
 
         status = (*mh)->hs_connect(dsn.c_str());
         if (status != HS_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "Cannot connect to ODBC SQL driver \'%s\', status %d. Check .odbc.ini and MIDAS documentation", dsn.c_str(), status);
            return status;
         }
 
         if (debug_flag)
            cm_msg(MINFO, "hs_get_history", "Connected history channel \'%s\' type ODBC (MySQL), DSN \'%s\'", key.name, dsn.c_str());
      }
   } else if (strcasecmp(type.c_str(), "SQLITE")==0) {
 
      std::string tmp;
      // create ODB "History dir"
      db_get_value_string(hDB, hKey, "History dir", 0, &tmp, TRUE);
 
      std::string path = cm_get_history_path(key.name);
 
      if (active || (flags & HS_GET_INACTIVE)) {
         *mh = MakeMidasHistorySqlite();
         if (*mh == NULL)
            return HS_FILE_ERROR;
         
         (*mh)->hs_set_debug(debug);
 
         status = (*mh)->hs_connect(path.c_str());
         if (status != HS_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "Cannot connect to SQLITE history, status %d, see messages", status);
            return status;
         }
 
         if (debug_flag)
            cm_msg(MINFO, "hs_get_history", "Connected history channel \'%s\' type SQLITE in \'%s\'", key.name, path.c_str());
      }
   } else if (strcasecmp(type.c_str(), "FILE")==0) {
 
      std::string tmp;
      // create ODB "History dir"
      db_get_value_string(hDB, hKey, "History dir", 0, &tmp, TRUE);
 
      std::string path = cm_get_history_path(key.name);
 
      //printf("FILE path [%s], expt_path [%s], local History Dir [%s]\n", path.c_str(), expt_path, dir);
 
      if (active || (flags & HS_GET_INACTIVE)) {
         *mh = MakeMidasHistoryFile();
         if (*mh == NULL)
            return HS_FILE_ERROR;
         
         (*mh)->hs_set_debug(debug);
         
         status = (*mh)->hs_connect(path.c_str());
         if (status != HS_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "Cannot connect to FILE history, status %d, see messages", status);
            return status;
         }
         
         if (debug_flag)
            cm_msg(MINFO, "hs_get_history", "Connected history channel \'%s\' type FILE in \'%s\'", key.name, path.c_str());
      }
   } else if (strcasecmp(type.c_str(), "MYSQL")==0) {
 
      std::string writer_dsn = "mysql_writer.txt";
      std::string reader_dsn = "mysql_reader.txt";
 
      status = db_get_value_string(hDB, hKey, "MYSQL Writer", 0, &writer_dsn, TRUE);
      assert(status == DB_SUCCESS);
 
      status = db_get_value_string(hDB, hKey, "MYSQL Reader", 0, &reader_dsn, TRUE);
      assert(status == DB_SUCCESS);
 
      std::string dsn;
 
      if (flags & HS_GET_READER)
         dsn = reader_dsn;
      else if (flags & HS_GET_WRITER)
         dsn = writer_dsn;
 
      std::string path;
 
      if (dsn[0] == DIR_SEPARATOR)
         path = dsn;
      else {
         std::string expt_path = cm_get_path();
 
         path = expt_path;
         // normally expt_path has the trailing '/', see midas.c::cm_set_path()
         if (path[path.length() - 1] != DIR_SEPARATOR)
            path += DIR_SEPARATOR_STR;
         path += dsn;
      }
 
      if (active || (flags & HS_GET_INACTIVE)) {
         *mh = MakeMidasHistoryMysql();
         if (*mh == NULL)
            return HS_FILE_ERROR;
 
         (*mh)->hs_set_debug(debug);
 
         status = (*mh)->hs_connect(path.c_str());
         if (status != HS_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "Cannot connect to MYSQL history, status %d", status);
            return status;
         }
 
         if (debug_flag)
            cm_msg(MINFO, "hs_get_history", "Connected history channel \'%s\' type MYSQL at \'%s\'", key.name,
                   path.c_str());
      }
   } else if (strcasecmp(type.c_str(), "PGSQL")==0) {
 
      std::string writer_dsn = "pgsql_writer.txt";
      std::string reader_dsn = "pgsql_reader.txt";
 
      status = db_get_value_string(hDB, hKey, "PGSQL Writer", 0, &writer_dsn, TRUE);
      assert(status == DB_SUCCESS);
 
      status = db_get_value_string(hDB, hKey, "PGSQL Reader", 0, &reader_dsn, TRUE);
      assert(status == DB_SUCCESS);
 
      std::string dsn;
 
      if (flags & HS_GET_READER)
         dsn = reader_dsn;
      else if (flags & HS_GET_WRITER)
         dsn = writer_dsn;
 
      std::string path;
 
      if (dsn[0] == DIR_SEPARATOR)
         path = dsn;
      else {
         std::string expt_path = cm_get_path();
 
         path = expt_path;
         // normally expt_path has the trailing '/', see midas.c::cm_set_path()
         if (path[path.length() - 1] != DIR_SEPARATOR)
            path += DIR_SEPARATOR_STR;
         path += dsn;
      }
 
      int downsample = 0;
      size = sizeof(downsample);
      status = db_get_value(hDB, hKey, "Enable downsampling queries", &downsample, &size, TID_BOOL, TRUE);
      assert(status == DB_SUCCESS);
 
      if (active || (flags & HS_GET_INACTIVE)) {
         *mh = MakeMidasHistoryPgsql();
         if (*mh == NULL)
            return HS_FILE_ERROR;
 
         (*mh)->hs_set_debug(debug);
         //(*mh)->hs_set_downsample(downsample);
 
         status = (*mh)->hs_connect(path.c_str());
         if (status != HS_SUCCESS) {
            cm_msg(MERROR, "hs_get_history", "Cannot connect to PGSQL history, status %d", status);
            return status;
         }
 
         if (debug_flag)
            cm_msg(MINFO, "hs_get_history", "Connected history channel \'%s\' type PGSQL at \'%s\'", key.name,
                   path.c_str());
      }
   } else if (strcasecmp(type.c_str(), "IMAGE")==0) {
      if (debug_flag)
         cm_msg(MINFO, "hs_get_history", "History channel \'IMAGE\' handled by image facility");
   } else {
      cm_msg(MERROR, "hs_get_history", "Logger history channel /Logger/History/%s/Type has invalid value \'%s\', valid values are MIDAS, ODBC, SQLITE, MYSQL, FILE and IMAGE", key.name, type.c_str());
      return HS_FILE_ERROR;
   }
 
   if (*mh == NULL)
      return HS_FILE_ERROR;
   
   mstrlcpy((*mh)->name, key.name, sizeof((*mh)->name));
   mstrlcpy((*mh)->type, type.c_str(), sizeof((*mh)->type));
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_read_event_list()

int hs_read_event_list

(

std::vector< std::string > *

pevents

)

Definition at line 426 of file history_common.cxx.

{
   std::string fname = hs_event_list_filename();
 
   FILE *fp = fopen(fname.c_str(), "r");
   if (!fp) {
      cm_msg(MERROR, "hs_read_event_list", "Cannot open file \'%s\', errno %d (%s)", fname.c_str(), errno, strerror(errno));
      return HS_FILE_ERROR;
   }
 
   while (1) {
      char buf[256];
      char *s = fgets(buf, sizeof(buf), fp);
      if (!s) // EOF
         break;
      // kill trailing \n and \r
      s = strchr(buf, '\n');
      if (s)
         *s = 0;
      s = strchr(buf, '\r');
      if (s)
         *s = 0;
      pevents->push_back(buf);
   }
 
   fclose(fp);
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_save_event_list()

int hs_save_event_list

(

const std::vector< std::string > *

pevents

)

Definition at line 396 of file history_common.cxx.

{
   std::string ss;
   for (unsigned i=0; i<pevents->size(); i++)
      ss += (*pevents)[i] + "\n";
 
   std::string fname = hs_event_list_filename();
 
   FILE *fp = fopen(fname.c_str(), "w");
   if (!fp) {
      cm_msg(MERROR, "hs_save_event_list", "Cannot open file \'%s\', errno %d (%s)", fname.c_str(), errno, strerror(errno));
      return HS_FILE_ERROR;
   }
 
   const char* s = ss.c_str();
   int len = strlen(s);
 
   int wr = write(fileno(fp), s, len);
 
   if (wr != len) {
      cm_msg(MERROR, "hs_save_event_list", "Cannot write to file \'%s\', errno %d (%s)", fname.c_str(), errno, strerror(errno));
      fclose(fp);
      return HS_FILE_ERROR;
   }
 
   fclose(fp);
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistoryFile()

MidasHistoryInterface * MakeMidasHistoryFile

(

)

Definition at line 7030 of file history_schema.cxx.

{
   return new FileHistory();
}

Here is the caller graph for this function:

MakeMidasHistoryMysql()

MidasHistoryInterface * MakeMidasHistoryMysql

(

)

Definition at line 7010 of file history_schema.cxx.

{
#ifdef HAVE_MYSQL
   return new MysqlHistory();
#else
   cm_msg(MERROR, "MakeMidasHistoryMysql", "Error: Cannot initialize MySQL history - this MIDAS was built without MySQL support - HAVE_MYSQL is not defined");
   return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistoryODBC()

MidasHistoryInterface * MakeMidasHistoryODBC

(

)

Definition at line 2150 of file history_odbc.cxx.

{
   return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistoryPgsql()

MidasHistoryInterface * MakeMidasHistoryPgsql

(

)

Definition at line 7020 of file history_schema.cxx.

{
#ifdef HAVE_PGSQL
   return new PgsqlHistory();
#else
   cm_msg(MERROR, "MakeMidasHistoryPgsql", "Error: Cannot initialize PgSQL history - this MIDAS was built without PostgreSQL support - HAVE_PGSQL is not defined");
   return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistorySqlDebug()

MidasHistoryInterface * MakeMidasHistorySqlDebug

(

)

Definition at line 2156 of file history_odbc.cxx.

{
   return new SqlHistory(new SqlDebug());
}

Here is the caller graph for this function:

MakeMidasHistorySqlite()

MidasHistoryInterface * MakeMidasHistorySqlite

(

)

Definition at line 7000 of file history_schema.cxx.

{
#ifdef HAVE_SQLITE
   return new SqliteHistory();
#else
   cm_msg(MERROR, "MakeMidasHistorySqlite", "Error: Cannot initialize SQLITE history - this MIDAS was built without SQLITE support - HAVE_SQLITE is not defined");
   return NULL;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function: