In This Package:

Manager.cc

Go to the documentation of this file.

#include "Manager.hh"
#include "FormString.hh"
#include <iostream>
#include <fstream>
#include <cassert>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

using namespace Logging;

//hxt ClassImp(Manager)

DEFINE_LOG(log_manager) // it logs itself!

Logging::Manager::Manager()
{
   // At first creation, start up a default stream with a default rule that everything goes there.
  AttachStream("*","stdout");
}

Logging::Manager::~Manager()
{
  std::map<std::string,std::ofstream*>::iterator it;
  for(it = mOpenFiles.begin(); it!= mOpenFiles.end(); it++) {
    (it->second)->flush();
    (it->second)->close();
    delete(it->second);
  }
  mOpenFiles.clear();
}

void Logging::Manager::ResetRules()
{
  mLevelRules.clear();
  mStreamRules.clear();
  ApplyRules();
}

void Logging::Manager::AppendSetLevelRule(std::string logpattern, Level lvl)
{
  LevelRule lr;
  lr.mLogPattern = logpattern;
  lr.mLevel      = lvl;
  mLevelRules.push_back(lr);
  ApplyRules();
}

void Logging::Manager::PrependSetLevelRule(std::string logpattern, Level lvl)
{
  LevelRule lr;
  lr.mLogPattern = logpattern;
  lr.mLevel      = lvl;
  mLevelRules.push_front(lr);
  ApplyRules();
}

void Logging::Manager::AttachStream(std::string logpattern, std::string streamname)
{
  StreamRule sr;
  sr.mLogPattern = logpattern;
  sr.mStreamName = streamname;
  mStreamRules.push_back(sr);
  ApplyRules();
}

LogStream& Logging::Manager::GetStream( std::string name )
{
  // Find an old one by this name
  std::map<std::string,LogStream>::iterator it = mLogStreams.find(name);
  if(it != mLogStreams.end()) return it->second;

  mLogStreams[name] = LogStream(name); // Make a new one
  return mLogStreams[name];  
}

std::ostream* Logging::Manager::GetOStream( std::string name )
{
  std::map<std::string,std::ofstream*>::iterator it = mOpenFiles.find(name);
  if(it != mOpenFiles.end()) return it->second;

  // OK, it doesn't exist. Create the file.
  std::ofstream* newstream = 0;

  if(name.find('%')==std::string::npos) {
    // Just create a new file; replace any existing file.
    newstream = new std::ofstream(name.c_str(), std::ios_base::out | std::ios_base::trunc);
  } else {
    // Use a log file number. Increment until we find an empty file.
    std::string trialname = name;  
    std::string::size_type p = trialname.find_last_of('%');
    int num = 1;
    int notexist=0;

    // Attempt to just name it the base name.
    trialname = name;
    trialname.replace(p,1,"");
    static struct stat stats;
    notexist = stat(trialname.c_str(),&stats);

    while(notexist==0) {
      // Ok, that file exists,so replace % with .001 and try again. (Then .002, etc)
      trialname = name;
      trialname.replace(p,1,FormString(".%03d",num++));
      notexist = stat(trialname.c_str(),&stats);
    }

    newstream = new std::ofstream(trialname.c_str(), std::ios_base::out | std::ios_base::trunc);
  }

  assert(newstream);
  assert(newstream->good());

  mOpenFiles[name]=newstream;
  return newstream;
}

void Logging::Manager::RegisterLog( Log* log )
{
  mLogs.insert(log);
  ApplyRules(log);
}


void Logging::Manager::DeRegisterLog( Log* log )
{
  mLogs.erase(log);
}

void Logging::Manager::ApplyRules()
{
  std::set<Log*>::iterator it;
  for(it = mLogs.begin(); it!= mLogs.end(); it++) ApplyRules(*it);
  
  //PrintRules();
  //PrintCurrentConfig();
}


bool PatternMatches(const std::string& pattern, const std::string& target)
{
  // Poor man's pattern matcher.
  // Match thing to thing
  if(pattern==target) return true;
  // Match blah* to blahanything
  std::string::size_type starpos = pattern.find_first_of('*',0);
  if(starpos != std::string::npos) {
                 // There was a wildcard. See if the substring before matches.
    if(pattern.compare(0,starpos, target,0,starpos) ==0) return true;
  }
  return false;
}


void Logging::Manager::ApplyRules(Log* log)
{
  // The core of the configuration utility. 
  // Try to apply all the currently-cached rules, in order, to the the given log.

  log->ResetStreams(); // Clear out any existing streams.
  for(unsigned int i=0; i< mStreamRules.size(); i++) {
    if(PatternMatches(mStreamRules[i].mLogPattern, log->GetName())) {
      log->ConnectStream(
        &GetStream(mStreamRules[i].mStreamName) 
        );
    }
  }

  log->Enable(Logging::kDefault); // Set to default level  
  for(unsigned int i=0; i< mLevelRules.size(); i++) {
    if(PatternMatches(mLevelRules[i].mLogPattern, log->GetName())) {
      log->Enable(mLevelRules[i].mLevel);
    }
  }
}

void Logging::Manager::PrintRules(Logging::Level lvl)
{
  LOG(log_manager,lvl) << "Complete level rules:";
  for(unsigned int i=0; i< mLevelRules.size(); i++) {
    LOG(log_manager,lvl) << mLevelRules[i].mLogPattern << " --> " << LevelToString(mLevelRules[i].mLevel); 
  }
  LOG(log_manager,lvl) << "Complete stream rules:";
  for(unsigned int i=0; i< mStreamRules.size(); i++) {
    LOG(log_manager,lvl) << mStreamRules[i].mLogPattern << " --> " << mStreamRules[i].mStreamName; 
  }
}

void Logging::Manager::PrintCurrentConfig(Logging::Level lvl)
{
  LOG(log_manager,lvl) << "Current logs:";
  LOG(log_manager,lvl) << "LogName     Current Level     Streams";
  std::set<Log*>::iterator it;
  for(it = mLogs.begin(); it!= mLogs.end(); it++) {
    Log* log = *it; 
    assert(log);
    const std::set<LogStream*>& streams = log->GetStreams(); 
    std::set<LogStream*>::const_iterator sit;
    std::string streamnames;
    for(sit=streams.begin();sit!=streams.end(); ++sit) {
      streamnames += (*sit)->GetName();
      streamnames += " ";
    }

    LOG(log_manager,lvl) << log->GetName() << "\t" 
                         << LevelToString(log->GetLevel()) << "\t"
                         << streamnames;
  }
}

---