PathResolver Class Reference

#include <PathResolver.h>

Collaboration diagram for PathResolver:

Public Types
enum	SearchPathStatus { Ok, EnvironmentVariableUndefined, UnknownDirectory }
enum	SearchType { LocalSearch, RecursiveSearch }
enum	PR_file_type { PR_regular_file, PR_directory }

Public Member Functions
	PathResolver ()

Static Public Member Functions
static std::string	find_file (const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
static std::string	find_file_from_list (const std::string &logical_file_name, const std::string &search_list, SearchType search_type=LocalSearch)
static std::string	find_directory (const std::string &logical_file_name, const std::string &search_path, SearchType search_type=LocalSearch)
static std::string	find_directory_from_list (const std::string &logical_file_name, const std::string &search_list, SearchType search_type=LocalSearch)
static SearchPathStatus	check_search_path (const std::string &search_path)
static std::string	find_calib_file (const std::string &logical_file_name)
static std::string	find_calib_directory (const std::string &logical_file_name)
static void	setOutputLevel (MSG::Level level)
static std::string	FindCalibFile (const std::string &logical_file_name)
static std::string	FindCalibDirectory (const std::string &logical_file_name)
static void	SetOutputLevel (int lvl)

Static Private Member Functions
static bool	PR_find (const std::string &logical_file_name, const std::string &search_list, PR_file_type file_type, SearchType search_type, std::string &result)
static bool	msgLvl (const MSG::Level lvl)
static MsgStream &	msg ()
static MsgStream &	msg (const MSG::Level lvl)
static asg::AsgMessaging &	asgMsg ()

Static Private Attributes
static std::atomic< MSG::Level >	m_level =MSG::INFO

Detailed Description

Definition at line 14 of file PathResolver.h.

Member Enumeration Documentation

PR_file_type

enum PathResolver::PR_file_type

Enumerator
PR_regular_file
PR_directory

Definition at line 31 of file PathResolver.h.

                {
      PR_regular_file,
      PR_directory
   } PR_file_type;

SearchPathStatus

enum PathResolver::SearchPathStatus

Enumerator
Ok
EnvironmentVariableUndefined
UnknownDirectory

Definition at line 18 of file PathResolver.h.

    {
      Ok,
      EnvironmentVariableUndefined,
      UnknownDirectory
    } SearchPathStatus;

SearchType

enum PathResolver::SearchType

Enumerator
LocalSearch
RecursiveSearch

Definition at line 25 of file PathResolver.h.

    {
      LocalSearch,
      RecursiveSearch
    } SearchType;

Constructor & Destructor Documentation

PathResolver()

PathResolver::PathResolver

(

)

Definition at line 94 of file PathResolver.cxx.

{ }

Member Function Documentation

asgMsg()

asg::AsgMessaging & PathResolver::asgMsg ( )

staticprivate

In AnalysisBase this method is not available

Definition at line 96 of file PathResolver.cxx.

                                      {
#ifdef XAOD_STANDALONE
   static thread_local asg::AsgMessaging asgMsg("PathResolver");
#else
   static asg::AsgMessaging asgMsg ATLAS_THREAD_SAFE ("PathResolver");
#endif
#ifndef XAOD_ANALYSIS
   asgMsg.setLevel(m_level);   
#else
   asgMsg.msg().setLevel(m_level);
#endif
   return asgMsg;
}

check_search_path()

PathResolver::SearchPathStatus PathResolver::check_search_path ( const std::string &  search_path )

static

• search_path the name of a path-like environment variable

Returns

the result of the verification. Can be one of Ok, EnvironmentVariableUndefined, UnknownDirectory

Definition at line 348 of file PathResolver.cxx.

{
  std::string path_list = gSystem->Getenv(search_path.c_str());
  if ( path_list.empty() )
    return (EnvironmentVariableUndefined);
 
  vector<string> spv;
  boost::split( spv, path_list, boost::is_any_of( path_separator ), boost::token_compress_on);
  vector<string>::iterator itr=spv.begin();
 
  try {
    for (; itr!= spv.end(); ++itr) {
      bf::path pp(*itr);
      if (!is_directory(pp)) {
        return (UnknownDirectory);
      }
    }
  } catch(const bf::filesystem_error& /*err*/) {
    return (UnknownDirectory);
  }
 
  return ( Ok );
}

find_calib_directory()

std::string PathResolver::find_calib_directory ( const std::string &  logical_file_name )

static

Definition at line 413 of file PathResolver.cxx.

{
  checkForDev(asgMsg(), logical_file_name);
  //expand filename before finding 
  TString tmpString(logical_file_name);
  gSystem->ExpandPathName(tmpString);
  std::string expandedFileName(tmpString.Data());
  boost::algorithm::trim(expandedFileName);
  std::string out = PathResolver::find_directory (expandedFileName, "CALIBPATH");
  if(out=="") msg(MSG::WARNING) <<"Could not locate " << logical_file_name << endmsg;
   return out;
}

find_calib_file()

std::string PathResolver::find_calib_file ( const std::string &  logical_file_name )

static

Definition at line 384 of file PathResolver.cxx.

{
  checkForDev(asgMsg(), logical_file_name);
  //expand filename before finding .. 
  TString tmpString(logical_file_name);
  gSystem->ExpandPathName(tmpString);
  if(tmpString.BeginsWith("root://")) {
    //xrootd access .. try to open file ...
    TFile* fTmp = TFile::Open(tmpString);
    if(!fTmp || fTmp->IsZombie()) {
      msg(MSG::WARNING) << "Could not open " << logical_file_name << endmsg;
      tmpString = "";
    }
    
    if(fTmp) {
      fTmp->Close();
      delete fTmp;
    }
    
    return tmpString.Data();
  }
  std::string expandedFileName(tmpString.Data());
   //strip any spaces off of the name
  boost::algorithm::trim(expandedFileName);
  std::string out = PathResolver::find_file (expandedFileName, "CALIBPATH");
  if(out=="") msg(MSG::WARNING) <<"Could not locate " << logical_file_name << endmsg;
   return out;
}

find_directory()

string PathResolver::find_directory ( const std::string &  logical_file_name, const std::string &  search_path, SearchType  search_type = LocalSearch  )

static

• logical_file_name the name of the directory to locate in the search path
• search_path the name of a path-like environment variable
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located directory or empty string if not found

Definition at line 307 of file PathResolver.cxx.

{
     std::string path_list;
 
#ifdef XAOD_STANDALONE
   const char* envVarVal = gSystem->Getenv(search_path.c_str());
   if(envVarVal == NULL) {
      msg(MSG::WARNING) <<search_path.c_str() << " environment variable not defined!" << endmsg;
      path_list = ""; //this will allow search in pwd ... maybe we should throw exception though!
   }
   else { path_list = envVarVal; }
#else
  System::getEnv(search_path, path_list);
#endif
 
  return (find_directory_from_list (logical_file_name, path_list, search_type));
}

find_directory_from_list()

string PathResolver::find_directory_from_list ( const std::string &  logical_file_name, const std::string &  search_list, SearchType  search_type = LocalSearch  )

static

• logical_file_name the name of the directory to locate in the search path
• search_list the prioritized list of possible locations separated by the usual path separator
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located directory or empty string if not found

Definition at line 330 of file PathResolver.cxx.

{
  std::string result;
 
  if (!PR_find (logical_file_name, search_list, PR_directory, search_type, result))
  {
    result = "";
  }
 
  return (result);
}

find_file()

string PathResolver::find_file ( const std::string &  logical_file_name, const std::string &  search_path, SearchType  search_type = LocalSearch  )

static

• logical_file_name the name of the file to locate in the search path
• search_path the name of a path-like environment variable
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located file or empty string if not found

Definition at line 251 of file PathResolver.cxx.

                                      {
   //std::cout << "finding file: " <<logical_file_name << " in path=" << search_path);
 
  std::string path_list;
 
#ifdef XAOD_STANDALONE
   const char* envVarVal = gSystem->Getenv(search_path.c_str());
   if(envVarVal == NULL) {
      msg(MSG::WARNING) <<search_path.c_str() << " environment variable not defined!" << endmsg;
      path_list = ""; //this will allow search in pwd ... maybe we should throw exception though!
   }
   else { path_list = envVarVal; }
#else
  System::getEnv(search_path, path_list);
#endif
 
#ifndef XAOD_ANALYSIS
  if (!logical_file_name.empty() && logical_file_name[0]=='/') {
    msg(MSG::ERROR) << "Use of an absolute file name: " << logical_file_name << endmsg;
  }
#endif
 
  return (find_file_from_list (logical_file_name, path_list, search_type));
}

find_file_from_list()

std::string PathResolver::find_file_from_list ( const std::string &  logical_file_name, const std::string &  search_list, SearchType  search_type = LocalSearch  )

static

• logical_file_name the name of the file to locate in the search path
• search_list the prioritized list of possible locations separated by the usual path separator
• search_type characterizes the type of search. Can be either LocalSearch or RecursiveSearch

Returns

the physical name of the located file or empty string if not found

Definition at line 281 of file PathResolver.cxx.

{
  std::string result("");
 
  
 
  /* bool found = */
  PR_find (logical_file_name, search_list, PR_regular_file, search_type, result);
 
  // The following functionality was in the original PathResolver, but I believe
  // that it's WRONG. It extracts the filename of the requested item, and searches
  // for that if the preceding search fails. i.e., if you're looking for "B/a.txt",
  // and that fails, it will look for just "a.txt" in the search list.
 
  // if (! found && lfn.filename() != lfn ) {
  //   result = "";
  //   PR_find (lfn.filename(), search_list, PR_regular_file, search_type, result);
  // }
 
  return (result);
}

FindCalibDirectory()

static std::string PathResolver::FindCalibDirectory ( const std::string &  logical_file_name )

inlinestatic

Definition at line 109 of file PathResolver.h.

{ return find_calib_directory(logical_file_name); }

FindCalibFile()

static std::string PathResolver::FindCalibFile ( const std::string &  logical_file_name )

inlinestatic

Definition at line 108 of file PathResolver.h.

{ return find_calib_file(logical_file_name); }

msg() [1/2]

static MsgStream& PathResolver::msg ( )

inlinestaticprivate

Definition at line 120 of file PathResolver.h.

{ return asgMsg().msg(); }

msg() [2/2]

static MsgStream& PathResolver::msg ( const MSG::Level  lvl )

inlinestaticprivate

Definition at line 121 of file PathResolver.h.

{ return asgMsg().msg(lvl); }

msgLvl()

static bool PathResolver::msgLvl ( const MSG::Level  lvl )

inlinestaticprivate

Definition at line 119 of file PathResolver.h.

{ return asgMsg().msgLvl(lvl); }

PR_find()

bool PathResolver::PR_find ( const std::string &  logical_file_name, const std::string &  search_list, PR_file_type  file_type, PathResolver::SearchType  search_type, std::string &  result  )

staticprivate

Definition at line 122 of file PathResolver.cxx.

                          {
 
   std::string trimmed_logical_file_name = logical_file_name;
   boost::algorithm::trim(trimmed_logical_file_name); //trim again for extra safety
 
   bf::path file( trimmed_logical_file_name );
 
  bool found(false);
 
  // look for file as specified first
 
  try {
    if ( ( file_type == PR_regular_file && is_regular_file( file ) ) ||
         ( file_type == PR_directory && is_directory( file ) ) ) {
      result = bf::system_complete(file).string();
      return true;
    }
  } catch (const bf::filesystem_error& /*err*/) {
  }
 
  // assume that "." is always part of the search path, so check locally first
 
  try {
    bf::path local = bf::initial_path() / file;
    if ( ( file_type == PR_regular_file && is_regular_file( local ) ) ||
         ( file_type == PR_directory && is_directory( local ) ) ) {
      result = bf::system_complete(file).string();
      return true;
    }
  } catch (const bf::filesystem_error& /*err*/) {
  }
 
   std::string locationToDownloadTo = "."; //will replace with first search location 
 
  // iterate through search list
  vector<string> spv;
  split(spv, search_list, boost::is_any_of( path_separator), boost::token_compress_on);
  for (vector<string>::const_iterator itr = spv.begin();
       itr != spv.end(); ++itr ) {
 
   if( itr->find("http//")==0 && file_type==PR_regular_file && gSystem->Getenv("PATHRESOLVER_ALLOWHTTPDOWNLOAD") ) { //only http download files, not directories
      //try to do an http download to the local location
      //restore the proper http protocal (had to remove for sake of env var splitting) 
      std::string addr = "http://"; addr += itr->substr(6,itr->length());
      bf::path lp = locationToDownloadTo/file;
      bf::path lpd = lp; lpd.remove_filename();
      msg(MSG::DEBUG) <<"Attempting http download of " << addr << "/" << file.string() << " to " << lp << endmsg;
 
      if(!is_directory(lpd)) {
         msg(MSG::DEBUG) <<"   Creating directory: " << lpd  << endmsg;
         if(!boost::filesystem::create_directories(lpd)) {
            msg(MSG::DEBUG) <<"Unable to create directories to write file to : " << lp << endmsg;
            continue;
            //throw std::runtime_error("Unable to download calibration file");
         }
      }
      std::string fileToDownload = addr + "/" + file.string();
      std::string targetPath = locationToDownloadTo+"/"+file.string();
      //disable error output from root while attempting to download
      // FIXME: Disabling errors now commented out because it is not
      //        thread-safe.  Needs changes in ROOT.
      //long errLevel = gErrorIgnoreLevel;
      //gErrorIgnoreLevel = kError+1;
      if(!TFile::Cp(fileToDownload.c_str(),targetPath.c_str(), false)) {
         msg(MSG::WARNING) <<"Unable to download file : " << fileToDownload << endmsg;
      } else {
         msg(MSG::DEBUG) <<"Successfully downloaded " << fileToDownload << endmsg;
         result = (locationToDownloadTo+"/"+file.string()).c_str();
         //gErrorIgnoreLevel=errLevel;
         return true;
      }
      //gErrorIgnoreLevel=errLevel;
   } else if(locationToDownloadTo=="." && itr->find("/afs/cern.ch/atlas/www/")==std::string::npos) { //don't let it ever download back to the www area!
      //prefer first non-pwd location for downloading to. But must be fully accessible. This should be the local InstallArea in cmt
     FILE *fp = std::fopen((*itr+"/._pathresolver_dummy").c_str(), "a+");
     if(fp!=NULL) {
         locationToDownloadTo=*itr;
         std::fclose(fp);
         (void)std::remove((*itr+"/._pathresolver_dummy").c_str());
      }
   }
 
   //std::cout << "searching path: " << *itr);
 
    bf::path fp = *itr / file;
 
    try {
      if ( ( file_type == PR_regular_file && is_regular_file( fp ) ) ||
           ( file_type == PR_directory && is_directory( fp ) ) ) {
        result = bf::system_complete(fp).string();
        return true;
      }
    } catch (const bf::filesystem_error& /*err*/) {
    }
 
 
    // if recursive searching requested, drill down
    if (search_type == PathResolver::RecursiveSearch &&
        is_directory( bf::path(*itr) ) ) {
 
      bf::recursive_directory_iterator end_itr;
      try {
        for ( bf::recursive_directory_iterator ritr( *itr );
              ritr != end_itr; ++ritr) {
 
          // skip if not a directory
          if (! is_directory( bf::path(*ritr) ) ) { continue; }
 
          bf::path fp2 = bf::path(*ritr) / file;
          if ( ( file_type == PR_regular_file && is_regular_file( fp2 ) ) ||
               ( file_type == PR_directory && is_directory( fp2 ) ) ) {
            result = bf::system_complete( fp2 ).string();
            return true;
          }
        }
      } catch (const bf::filesystem_error& /*err*/) {
      }
    }
 
  }
 
  return found;
}

SetOutputLevel()

static void PathResolver::SetOutputLevel ( int  lvl )

inlinestatic

Definition at line 110 of file PathResolver.h.

{ setOutputLevel(MSG::Level(lvl)); }

setOutputLevel()

void PathResolver::setOutputLevel ( MSG::Level  level )

static

Definition at line 426 of file PathResolver.cxx.

                                                {
   m_level = level;
}

Member Data Documentation

m_level

std::atomic< MSG::Level > PathResolver::m_level =MSG::INFO

staticprivate

Definition at line 117 of file PathResolver.h.

---

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

• PathResolver.h
• PathResolver.cxx