FileHistory Class Reference

Inheritance diagram for FileHistory:

Collaboration diagram for FileHistory:

Public Member Functions
	FileHistory ()
int	hs_connect (const char *connect_string)
	returns HS_SUCCESS
int	hs_disconnect ()
	disconnect from history, returns HS_SUCCESS
int	hs_clear_cache ()
	clear internal cache, returns HS_SUCCESS
int	read_schema (HsSchemaVector *sv, const char *event_name, const time_t timestamp)
HsSchema *	new_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])
Public Member Functions inherited from SchemaHistoryBase
	SchemaHistoryBase ()
virtual	~SchemaHistoryBase ()
virtual int	hs_set_debug (int debug)
	set debug level, returns previous debug level
int	hs_define_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])
	see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	hs_write_event (const char *event_name, time_t timestamp, int buffer_size, const char *buffer)
	see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	hs_flush_buffers ()
	flush buffered data to storage where it is visible to mhttpd
int	hs_clear_cache ()
	clear internal cache, returns HS_SUCCESS
int	hs_get_events (time_t t, std::vector< std::string > *pevents)
	get list of events that exist(ed) at given time and later (value 0 means "return all events from beginning of time"), returns HS_SUCCESS
int	hs_get_tags (const char *event_name, time_t t, std::vector< TAG > *ptags)
	get list of history variables for given event (use event names returned by hs_get_events()) that exist(ed) at given time and later (value 0 means "all variables for this event that ever existed"), also see hs_get_tags(), returns HS_SUCCESS
int	hs_get_last_written (time_t timestamp, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], time_t last_written[])
int	hs_read_buffer (time_t start_time, time_t end_time, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], MidasHistoryBufferInterface *buffer[], int hs_status[])
	returns HS_SUCCESS
int	hs_read (time_t start_time, time_t end_time, time_t interval, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], int num_entries[], time_t *time_buffer[], double *data_buffer[], int st[])
	see hs_read(), returns HS_SUCCESS
int	hs_read_binned (time_t start_time, time_t end_time, int num_bins, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], int num_entries[], int *count_bins[], double *mean_bins[], double *rms_bins[], double *min_bins[], double *max_bins[], time_t *bins_first_time[], double *bins_first_value[], time_t *bins_last_time[], double *bins_last_value[], time_t last_time[], double last_value[], int st[])
	returns HS_SUCCESS
Public Member Functions inherited from MidasHistoryInterface
	MidasHistoryInterface ()
	history type: MIDAS, ODBC, SQLITE, etc
virtual	~MidasHistoryInterface ()

Protected Member Functions
int	create_file (const char *event_name, time_t timestamp, const std::vector< HsSchemaEntry > &vars, std::string *filenamep)
HsFileSchema *	read_file_schema (const char *filename)
int	read_file_list (bool *pchanged)
void	clear_file_list ()
void	tags_to_variables (int ntags, const TAG tags[], std::vector< HsSchemaEntry > &variables)
HsSchema *	maybe_reopen (const char *event_name, time_t timestamp, HsSchema *s)

Protected Attributes
std::string	fPath
time_t	fPathLastMtime = 0
std::vector< std::string >	fSortedFiles
std::vector< bool >	fSortedRead
time_t	fConfMaxFileAge = 1*kMonth
off64_t	fConfMaxFileSize = 100*MiB
Protected Attributes inherited from SchemaHistoryBase
int	fDebug = 0
std::string	fConnectString
HsSchemaVector	fWriterSchema
std::vector< HsSchema * >	fWriterEvents
HsSchemaVector	fReaderSchema

Additional Inherited Members
Public Attributes inherited from MidasHistoryInterface
char	name [NAME_LENGTH]
char	type [NAME_LENGTH]
	history channel name

Detailed Description

Definition at line 6451 of file history_schema.cxx.

Constructor & Destructor Documentation

FileHistory()

FileHistory::FileHistory ( )

inline

Definition at line 6462 of file history_schema.cxx.

   {
      // empty
   }

Member Function Documentation

clear_file_list()

void FileHistory::clear_file_list ( )

protected

Definition at line 6520 of file history_schema.cxx.

{
   fPathLastMtime = 0;
   fSortedFiles.clear();
   fSortedRead.clear();
}

Here is the caller graph for this function:

create_file()

int FileHistory::create_file ( const char *  event_name, time_t  timestamp, const std::vector< HsSchemaEntry > &  vars, std::string *  filenamep  )

protected

Definition at line 6860 of file history_schema.cxx.

{
   if (fDebug)
      printf("FileHistory::create_file: event [%s]\n", event_name);
 
   // NB: file names are constructed in such a way
   // that when sorted lexicographically ("ls -1 | sort")
   // they *also* become sorted by time
 
   struct tm tm;
   localtime_r(&timestamp, &tm); // somebody must call tzset() before this.
 
   char buf[256];
   strftime(buf, sizeof(buf), "%Y%m%d", &tm);
 
   std::string filename;
   filename += fPath;
   filename += "mhf_";
   filename += TimeToString(timestamp);
   filename += "_";
   filename += buf;
   filename += "_";
   filename += MidasNameToFileName(event_name);
 
   std::string try_filename = filename + ".dat";
 
   FILE *fp = NULL;
   for (int itry=0; itry<10; itry++) {
      if (itry > 0) {
         char s[256];
         sprintf(s, "_%d", rand());
         try_filename = filename + s + ".dat";
      }
 
      fp = fopen(try_filename.c_str(), "r");
      if (fp != NULL) {
         // this file already exists, try with a different name
         fclose(fp);
         continue;
      }
 
      fp = fopen(try_filename.c_str(), "w");
      if (fp == NULL) {
         // somehow cannot create this file, try again
         cm_msg(MERROR, "FileHistory::create_file", "Error: Cannot create file \'%s\' for event \'%s\', fopen() errno %d (%s)", try_filename.c_str(), event_name, errno, strerror(errno));
         continue;
      }
 
      // file opened
      break;
   }
 
   if (fp == NULL) {
      // somehow cannot create any file, whine!
      cm_msg(MERROR, "FileHistory::create_file", "Error: Cannot create file \'%s\' for event \'%s\'", filename.c_str(), event_name);
      return HS_FILE_ERROR;
   }
 
   std::string ss;
 
   ss += "version: 2.0\n";
   ss += "event_name: ";
   ss    += event_name;
   ss    += "\n";
   ss += "time: ";
   ss    += TimeToString(timestamp);
   ss    += "\n";
 
   int recsize = 0;
 
   ss += "tag: /DWORD 1 4 /timestamp\n";
   recsize += 4;
 
   bool padded = false;
   int offset = 0;
 
   bool xdebug = false; // (strcmp(event_name, "u_Beam") == 0);
 
   for (size_t i=0; i<vars.size(); i++) {
      int tsize = rpc_tid_size(vars[i].type);
      int n_bytes = vars[i].n_data*tsize;
      int xalign = (offset % tsize);
 
      if (xdebug)
         printf("tag %zu, tsize %d, n_bytes %d, xalign %d\n", i, tsize, n_bytes, xalign);
 
#if 0
      // looks like history data does not do alignement and padding
      if (xalign != 0) {
         padded = true;
         int pad_bytes = tsize - xalign;
         assert(pad_bytes > 0);
 
         ss += "tag: ";
         ss    += "XPAD";
         ss    += " ";
         ss    += SmallIntToString(1);
         ss    += " ";
         ss    += SmallIntToString(pad_bytes);
         ss    += " ";
         ss    += "pad_";
         ss    += SmallIntToString(i);
         ss    += "\n";
 
         offset += pad_bytes;
         recsize += pad_bytes;
 
         assert((offset % tsize) == 0);
         fprintf(stderr, "FIXME: need to debug padding!\n");
         //abort();
      }
#endif
      
      ss += "tag: ";
      ss    += rpc_tid_name(vars[i].type);
      ss    += " ";
      ss    += SmallIntToString(vars[i].n_data);
      ss    += " ";
      ss    += SmallIntToString(n_bytes);
      ss    += " ";
      ss    += vars[i].name;
      ss    += "\n";
 
      recsize += n_bytes;
      offset += n_bytes;
   }
 
   ss += "record_size: ";
   ss    += SmallIntToString(recsize);
   ss    += "\n";
 
   // reserve space for "data_offset: ..."
   int sslength = ss.length() + 127;
 
   int block = 1024;
   int nb = (sslength + block - 1)/block;
   int data_offset = block * nb;
 
   ss += "data_offset: ";
   ss    += SmallIntToString(data_offset);
   ss    += "\n";
 
   fprintf(fp, "%s", ss.c_str());
 
   fclose(fp);
 
   if (1 && padded) {
      printf("Schema in file %s has padding:\n", try_filename.c_str());
      printf("%s", ss.c_str());
   }
 
   if (filenamep)
      *filenamep = try_filename;
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_clear_cache()

int FileHistory::hs_clear_cache ( )

virtual

clear internal cache, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 6501 of file history_schema.cxx.

{
   if (fDebug)
      printf("FileHistory::hs_clear_cache!\n");
   fPathLastMtime = 0;
   return SchemaHistoryBase::hs_clear_cache();
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_connect()

int FileHistory::hs_connect ( const char *  connect_string )

virtual

returns HS_SUCCESS

Implements SchemaHistoryBase.

Definition at line 6482 of file history_schema.cxx.

{
   if (fDebug)
      printf("hs_connect [%s]!\n", connect_string);
 
   hs_disconnect();
 
   fConnectString = connect_string;
   fPath = connect_string;
 
   // add trailing '/'
   if (fPath.length() > 0) {
      if (fPath[fPath.length()-1] != DIR_SEPARATOR)
         fPath += DIR_SEPARATOR_STR;
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_disconnect()

int FileHistory::hs_disconnect ( )

virtual

disconnect from history, returns HS_SUCCESS

Implements SchemaHistoryBase.

Definition at line 6509 of file history_schema.cxx.

{
   if (fDebug)
      printf("FileHistory::hs_disconnect!\n");
 
   hs_flush_buffers();
   hs_clear_cache();
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

maybe_reopen()

HsSchema * FileHistory::maybe_reopen ( const char *  event_name, time_t  timestamp, HsSchema *  s  )

protectedvirtual

Implements SchemaHistoryBase.

Definition at line 7186 of file history_schema.cxx.

{
   HsFileSchema* fs = dynamic_cast<HsFileSchema*>(s);
 
   assert(fs != NULL); // FileHistory::maybe_reopen() must be called only with file history schema.
 
   if (fs->fFileSize <= fConfMaxFileSize) {
      // not big enough, let it grow
      return s;
   }
 
   // must rotate the file
 
   if (fDebug) {
#ifdef OS_DARWIN
      printf("FileHistory::maybe_reopen: reopen file \"%s\", size %lld, max size %lld\n", fs->fFileName.c_str(), fs->fFileSize, fConfMaxFileSize);
#else
      printf("FileHistory::maybe_reopen: reopen file \"%s\", size %jd, max size %jd\n", fs->fFileName.c_str(), fs->fFileSize, fConfMaxFileSize);
#endif
   }
   
   std::string new_filename;
   
   int status = create_file(event_name, timestamp, fs->fVariables, &new_filename);
   
   if (status != HS_SUCCESS) {
      // cannot create new history file
      return s;
   }
   
   HsFileSchema* new_fs = read_file_schema(new_filename.c_str());
   
   if (!new_fs) {
      // cannot open new history file
      return s;
   }
 
   new_fs->fDisabled = false;
 
   HsFileSchema* new_fs_copy = new HsFileSchema;
   *new_fs_copy = *new_fs; // make a copy
 
   //printf("replacing schema %p %p with %p %p\n", s, fs, new_fs, new_fs_copy);
   
   for (size_t i=0; i<fWriterEvents.size(); i++) {
      if (s == fWriterEvents[i]) {
         delete fWriterEvents[i];
         fWriterEvents[i] = new_fs;
         s = NULL; // pointer to fEvents[i]
         fs = NULL; // pointer to fEvents[i]
      }
   }
   
   assert(s == NULL); // the schema we are replacing must be in fWriterEvents.
 
   fWriterSchema.add(new_fs_copy); // make sure new file is added to the list of files
   
   assert(new_fs->fFileSize < fConfMaxFileSize); // check that we are not returning the original big file
 
   //new_fs->print();
   
   return new_fs;
}

Here is the call graph for this function:

new_event()

HsSchema * FileHistory::new_event ( const char *  event_name, time_t  timestamp, int  ntags, const TAG  tags[]  )

virtual

Implements SchemaHistoryBase.

Definition at line 6706 of file history_schema.cxx.

{
   if (fDebug)
      printf("FileHistory::new_event: event [%s], timestamp %s, ntags %d\n", event_name, TimeToString(timestamp).c_str(), ntags);
 
   int status;
 
   HsFileSchema* s = (HsFileSchema*)fWriterSchema.find_event(event_name, timestamp);
 
   if (!s) {
      //printf("hs_define_event: no schema for event %s\n", event_name);
      status = read_schema(&fWriterSchema, event_name, timestamp);
      if (status != HS_SUCCESS)
         return NULL;
      s = (HsFileSchema*)fWriterSchema.find_event(event_name, timestamp);
   } else {
      //printf("hs_define_event: already have schema for event %s\n", s->fEventName.c_str());
   }
 
   bool xdebug = false;
 
   if (s) { // is existing schema the same as new schema?
      bool same = true;
 
      if (same) {
         if (s->fEventName != event_name) {
            if (xdebug)
               printf("AAA: [%s] [%s]!\n", s->fEventName.c_str(), event_name);
            same = false;
         }
      }
 
      if (same) {
         if (s->fVariables.size() != (size_t)ntags) {
            if (xdebug)
               printf("BBB: event [%s]: ntags: %zu -> %d!\n", event_name, s->fVariables.size(), ntags);
            same = false;
         }
      }
 
      if (same) {
         for (size_t i=0; i<s->fVariables.size(); i++) {
            if (s->fVariables[i].name != tags[i].name) {
               if (xdebug)
                  printf("CCC: event [%s] index %zu: name [%s] -> [%s]!\n", event_name, i, s->fVariables[i].name.c_str(), tags[i].name);
               same = false;
            }
            if (s->fVariables[i].type != (int)tags[i].type) {
               if (xdebug)
                  printf("DDD: event [%s] index %zu: type %d -> %d!\n", event_name, i, s->fVariables[i].type, tags[i].type);
               same = false;
            }
            if (s->fVariables[i].n_data != (int)tags[i].n_data) {
               if (xdebug)
                  printf("EEE: event [%s] index %zu: n_data %d -> %d!\n", event_name, i, s->fVariables[i].n_data, tags[i].n_data);
               same = false;
            }
            if (!same)
               break;
         }
      }
 
      if (!same) {
         if (xdebug) {
            printf("*** Schema for event %s has changed!\n", event_name);
 
            printf("*** Old schema for event [%s] time %s:\n", event_name, TimeToString(timestamp).c_str());
            s->print();
            printf("*** New tags:\n");
            PrintTags(ntags, tags);
         }
 
         if (fDebug)
            printf("FileHistory::new_event: event [%s], timestamp %s, ntags %d: schema mismatch, starting a new file.\n", event_name, TimeToString(timestamp).c_str(), ntags);
 
         s = NULL;
      }
   }
 
   if (s) {
      // maybe this schema is too old - rotate files every so often
      time_t age = timestamp - s->fTimeFrom;
      //printf("*** age %s (%.1f months), timestamp %s, time_from %s, file %s\n", TimeToString(age).c_str(), (double)age/(double)kMonth, TimeToString(timestamp).c_str(), TimeToString(s->fTimeFrom).c_str(), s->fFileName.c_str());
      if (age > fConfMaxFileAge) {
         if (fDebug)
            printf("FileHistory::new_event: event [%s], timestamp %s, ntags %d: schema is too old, age %.1f months, starting a new file.\n", event_name, TimeToString(timestamp).c_str(), ntags, (double)age/(double)kMonth);
 
         // force creation of a new file
         s = NULL;
      }
   }
 
   if (s) {
      // maybe this file is too big - rotate files to limit maximum size
      double size = ss_file_size(s->fFileName.c_str());
      //printf("*** size %.0f, file %s\n", size, s->fFileName.c_str());
      if (size > fConfMaxFileSize) {
         if (fDebug)
            printf("FileHistory::new_event: event [%s], timestamp %s, ntags %d: file too big, size %.1f MiBytes, max size %.1f MiBytes, starting a new file.\n", event_name, TimeToString(timestamp).c_str(), ntags, size/MiB, fConfMaxFileSize/MiB);
 
         // force creation of a new file
         s = NULL;
      }
   }
 
   if (!s) {
      std::string filename;
 
      std::vector<HsSchemaEntry> vars;
 
      tags_to_variables(ntags, tags, vars);
 
      status = create_file(event_name, timestamp, vars, &filename);
      if (status != HS_SUCCESS)
         return NULL;
 
      HsFileSchema* ss = read_file_schema(filename.c_str());
      if (!ss) {
         cm_msg(MERROR, "FileHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
         return NULL;
      }
 
      fWriterSchema.add(ss);
 
      s = (HsFileSchema*)fWriterSchema.find_event(event_name, timestamp);
 
      if (!s) {
         cm_msg(MERROR, "FileHistory::new_event", "Error: Cannot create schema for event \'%s\', see previous messages", event_name);
         return NULL;
      }
 
      if (xdebug) {
         printf("*** New schema for event [%s] time %s:\n", event_name, TimeToString(timestamp).c_str());
         s->print();
      }
   }
 
   assert(s != NULL);
 
#if 0
   {
      printf("schema for [%s] is %p\n", event_name, s);
      if (s)
         s->print();
   }
#endif
 
   HsFileSchema* e = new HsFileSchema();
 
   *e = *s; // make a copy of the schema
 
   return e;
}

Here is the call graph for this function:

read_file_list()

int FileHistory::read_file_list ( bool *  pchanged )

protected

Definition at line 6527 of file history_schema.cxx.

{
   int status;
   double start_time = ss_time_sec();
 
   if (pchanged)
      *pchanged = false;
 
   struct stat stat_buf;
   status = stat(fPath.c_str(), &stat_buf);
   if (status != 0) {
      cm_msg(MERROR, "FileHistory::read_file_list", "Cannot stat(%s), errno %d (%s)", fPath.c_str(), errno, strerror(errno));
      return HS_FILE_ERROR;
   }
 
   //printf("dir [%s], mtime: %d %d last: %d %d, mtime %s", fPath.c_str(), stat_buf.st_mtimespec.tv_sec, stat_buf.st_mtimespec.tv_nsec, last_mtimespec.tv_sec, last_mtimespec.tv_nsec, ctime(&stat_buf.st_mtimespec.tv_sec));
 
   if (stat_buf.st_mtime == fPathLastMtime) {
      if (fDebug)
         printf("FileHistory::read_file_list: history directory \"%s\" mtime %d did not change\n", fPath.c_str(), int(stat_buf.st_mtime));
      return HS_SUCCESS;
   }
 
   fPathLastMtime = stat_buf.st_mtime;
 
   if (fDebug)
      printf("FileHistory::read_file_list: reading list of history files in \"%s\"\n", fPath.c_str());
 
   std::vector<std::string> flist;
 
   ss_file_find(fPath.c_str(), "mhf_*.dat", &flist);
 
   double ls_time = ss_time_sec();
   double ls_elapsed = ls_time - start_time;
   if (ls_elapsed > 5.000) {
      cm_msg(MINFO, "FileHistory::read_file_list", "\"ls -l\" of \"%s\" took %.1f sec", fPath.c_str(), ls_elapsed);
      cm_msg_flush_buffer();
   }
 
   // note: reverse iterator is used to sort filenames by time, newest first
   std::sort(flist.rbegin(), flist.rend());
 
#if 0
   {
      printf("file names sorted by time:\n");
      for (size_t i=0; i<flist.size(); i++) {
         printf("%d: %s\n", i, flist[i].c_str());
      }
   }
#endif
 
   std::vector<bool> fread;
   fread.resize(flist.size()); // fill with "false"
 
   // loop over the old list of files,
   // for files we already read, loop over new file
   // list and mark the same file as read. K.O.
   for (size_t j=0; j<fSortedFiles.size(); j++) {
      if (fSortedRead[j]) {
         for (size_t i=0; i<flist.size(); i++) {
            if (flist[i] == fSortedFiles[j]) {
               fread[i] = true;
               break;
            }
         }
      }
   }
 
   fSortedFiles = flist;
   fSortedRead  = fread;
 
   if (pchanged)
      *pchanged = true;
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_file_schema()

HsFileSchema * FileHistory::read_file_schema ( const char *  filename )

protected

Definition at line 7017 of file history_schema.cxx.

{
   if (fDebug)
      printf("FileHistory::read_file_schema: file %s\n", filename);
 
   FILE* fp = fopen(filename, "r");
   if (!fp) {
      cm_msg(MERROR, "FileHistory::read_file_schema", "Cannot read \'%s\', fopen() errno %d (%s)", filename, errno, strerror(errno));
      return NULL;
   }
 
   HsFileSchema* s = NULL;
 
   // File format looks like this:
   // version: 2.0
   // event_name: u_Beam
   // time: 1023174012
   // tag: /DWORD 1 4 /timestamp
   // tag: FLOAT 1 4 B1
   // ...
   // tag: FLOAT 1 4 Ref Heater
   // record_size: 84
   // data_offset: 1024
 
   size_t rd_recsize = 0;
   int offset = 0;
 
   while (1) {
      char buf[1024];
      char* b = fgets(buf, sizeof(buf), fp);
 
      //printf("read: %s\n", b);
 
      if (!b) {
         break; // end of file
      }
 
      char*bb;
 
      bb = strchr(b, '\n');
      if (bb)
         *bb = 0;
 
      bb = strchr(b, '\r');
      if (bb)
         *bb = 0;
 
      bb = strstr(b, "version: 2.0");
      if (bb == b) {
         s = new HsFileSchema();
         assert(s);
 
         s->fFileName = filename;
         continue;
      }
 
      if (!s) {
         // malformed history file
         break;
      }
 
      bb = strstr(b, "event_name: ");
      if (bb == b) {
         s->fEventName = bb + 12;
         continue;
      }
 
      bb = strstr(b, "time: ");
      if (bb == b) {
         s->fTimeFrom = strtoul(bb + 6, NULL, 10);
         continue;
      }
 
      // tag format is like this:
      //
      // tag: FLOAT 1 4 Ref Heater
      //
      // "FLOAT" is the MIDAS type, "/DWORD" is special tag for the timestamp
      // "1" is the number of array elements
      // "4" is the total tag size in bytes (n_data*tid_size)
      // "Ref Heater" is the tag name
 
      bb = strstr(b, "tag: ");
      if (bb == b) {
         bb += 5; // now points to the tag MIDAS type
         const char* midas_type = bb;
         char* bbb = strchr(bb, ' ');
         if (bbb) {
            *bbb = 0;
            HsSchemaEntry t;
            if (midas_type[0] == '/') {
               t.type = 0;
            } else {
               t.type = rpc_name_tid(midas_type);
               if (t.type == 0) {
                  cm_msg(MERROR, "FileHistory::read_file_schema", "Unknown MIDAS data type \'%s\' in history file \'%s\'", midas_type, filename);
                  if (s)
                     delete s;
                  s = NULL;
                  break;
               }
            }
            bbb++;
            while (*bbb == ' ')
               bbb++;
            if (*bbb) {
               t.n_data = strtoul(bbb, &bbb, 10);
               while (*bbb == ' ')
                  bbb++;
               if (*bbb) {
                  t.n_bytes = strtoul(bbb, &bbb, 10);
                  while (*bbb == ' ')
                     bbb++;
                  t.name = bbb;
               }
            }
 
            if (midas_type[0] != '/') {
               s->fVariables.push_back(t);
               s->fOffsets.push_back(offset);
               offset += t.n_bytes;
            }
 
            rd_recsize += t.n_bytes;
         }
         continue;
      }
 
      bb = strstr(b, "record_size: ");
      if (bb == b) {
         s->fRecordSize = atoi(bb + 12);
         continue;
      }
 
      bb = strstr(b, "data_offset: ");
      if (bb == b) {
         s->fDataOffset = atoi(bb + 12);
         // data offset is the last entry in the file
         break;
      }
   }
 
   fclose(fp);
 
   if (!s) {
      cm_msg(MERROR, "FileHistory::read_file_schema", "Malformed history schema in \'%s\', maybe it is not a history file", filename);
      return NULL;
   }
 
   if (rd_recsize != s->fRecordSize) {
      cm_msg(MERROR, "FileHistory::read_file_schema", "Record size mismatch in history schema from \'%s\', file says %zu while total of all tags is %zu", filename, s->fRecordSize, rd_recsize);
      if (s)
         delete s;
      return NULL;
   }
 
   if (!s) {
      cm_msg(MERROR, "FileHistory::read_file_schema", "Could not read history schema from \'%s\', maybe it is not a history file", filename);
      if (s)
         delete s;
      return NULL;
   }
 
   if (fDebug > 1)
      s->print();
 
   return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_schema()

int FileHistory::read_schema ( HsSchemaVector *  sv, const char *  event_name, const time_t  timestamp  )

virtual

Implements SchemaHistoryBase.

Definition at line 6604 of file history_schema.cxx.

{
   if (fDebug)
      printf("FileHistory::read_schema: event [%s] at time %s\n", event_name, TimeToString(timestamp).c_str());
 
   if (sv->size() == 0) {
      if (fDebug)
         printf("FileHistory::read_schema: schema is empty, do a full reload from disk\n");
      clear_file_list();
   }
 
   BOOL old_call_watchdog = FALSE;
   DWORD old_timeout = 0;
   cm_get_watchdog_params(&old_call_watchdog, &old_timeout);
   cm_set_watchdog_params(old_call_watchdog, 0);
 
   bool changed = false;
 
   int status = read_file_list(&changed);
 
   if (status != HS_SUCCESS) {
      cm_set_watchdog_params(old_call_watchdog, old_timeout);
      return status;
   }
 
   if (!changed) {
      if ((*sv).find_event(event_name, timestamp)) {
         if (fDebug)
            printf("FileHistory::read_schema: event [%s] at time %s, no new history files, already have this schema\n", event_name, TimeToString(timestamp).c_str());
         cm_set_watchdog_params(old_call_watchdog, old_timeout);
         return HS_SUCCESS;
      }
   }
 
   double start_time = ss_time_sec();
 
   int count_read = 0;
 
   for (size_t i=0; i<fSortedFiles.size(); i++) {
      std::string file_name = fPath + fSortedFiles[i];
      if (fSortedRead[i])
         continue;
      //bool dupe = false;
      //for (size_t ss=0; ss<sv->size(); ss++) {
      //   HsFileSchema* ssp = (HsFileSchema*)(*sv)[ss];
      //   if (file_name == ssp->fFileName) {
      //      dupe = true;
      //      break;
      //   }
      //}
      //if (dupe)
      //   continue;
      fSortedRead[i] = true;
      HsFileSchema* s = read_file_schema(file_name.c_str());
      if (!s)
         continue;
      sv->add(s);
      count_read++;
 
      if (event_name) {
         if (s->fEventName == event_name) {
            //printf("file %s event_name %s time %s, age %f\n", file_name.c_str(), s->fEventName.c_str(), TimeToString(s->fTimeFrom).c_str(), double(timestamp - s->fTimeFrom));
            if (s->fTimeFrom <= timestamp) {
               // this file is older than the time requested,
               // subsequent files will be even older,
               // we can stop reading here.
               break;
            }
         }
      }
   }
 
   double end_time = ss_time_sec();
   double read_elapsed = end_time - start_time;
   if (read_elapsed > 5.000) {
      cm_msg(MINFO, "FileHistory::read_schema", "Loading schema for event \"%s\" timestamp %s, reading %d history files took %.1f sec", event_name, TimeToString(timestamp).c_str(), count_read, read_elapsed);
      cm_msg_flush_buffer();
   }
 
   cm_set_watchdog_params(old_call_watchdog, old_timeout);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tags_to_variables()

void FileHistory::tags_to_variables ( int  ntags, const TAG  tags[], std::vector< HsSchemaEntry > &  variables  )

protected

Definition at line 6688 of file history_schema.cxx.

{
   for (int i=0; i<ntags; i++) {
      HsSchemaEntry e;
 
      int tsize = rpc_tid_size(tags[i].type);
 
      e.tag_name = tags[i].name;
      e.tag_type = rpc_tid_name(tags[i].type);
      e.name     = tags[i].name;
      e.type     = tags[i].type;
      e.n_data   = tags[i].n_data;
      e.n_bytes  = tags[i].n_data*tsize;
 
      variables.push_back(e);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fConfMaxFileAge

time_t FileHistory::fConfMaxFileAge = 1*kMonth

protected

Definition at line 6458 of file history_schema.cxx.

fConfMaxFileSize

off64_t FileHistory::fConfMaxFileSize = 100*MiB

protected

Definition at line 6459 of file history_schema.cxx.

fPath

std::string FileHistory::fPath

protected

Definition at line 6454 of file history_schema.cxx.

fPathLastMtime

time_t FileHistory::fPathLastMtime = 0

protected

Definition at line 6455 of file history_schema.cxx.

fSortedFiles

std::vector<std::string> FileHistory::fSortedFiles

protected

Definition at line 6456 of file history_schema.cxx.

fSortedRead

std::vector<bool> FileHistory::fSortedRead

protected

Definition at line 6457 of file history_schema.cxx.

---

The documentation for this class was generated from the following file:

• src/history_schema.cxx