edm::FileLocator Class Reference

#include <FileLocator.h>

Classes
struct	Rule

Public Member Functions
	FileLocator (std::string const &catUrl, bool fallback)
std::string	lfn (std::string const &ipfn) const
std::string	pfn (std::string const &ilfn) const
	~FileLocator ()

Private Types
typedef std::map< std::string, Rules >	ProtocolRules
typedef std::vector< Rule >	Rules

Private Member Functions
std::string	applyRules (ProtocolRules const &protocolRules, std::string const &protocol, std::string const &destination, bool direct, std::string name) const
std::string	convert (std::string const &input, ProtocolRules const &rules, bool direct) const
void	init (std::string const &catUrl, bool fallback)
void	parseRule (xercesc::DOMNode *ruleNode, ProtocolRules &rules)

Private Attributes
std::string	m_destination
ProtocolRules	m_directRules
std::string	m_filename
std::string	m_fileType
ProtocolRules	m_inverseRules
std::vector< std::string >	m_protocols

Static Private Attributes
static int	s_numberOfInstances = 0

Detailed Description

Definition at line 13 of file FileLocator.h.

Member Typedef Documentation

typedef std::map<std::string, Rules> edm::FileLocator::ProtocolRules

private

Definition at line 35 of file FileLocator.h.

typedef std::vector<Rule> edm::FileLocator::Rules

private

Definition at line 34 of file FileLocator.h.

Constructor & Destructor Documentation

edm::FileLocator::FileLocator ( std::string const &  catUrl, bool  fallback  )

explicit

Definition at line 45 of file FileLocator.cc.

References MillePedeFileConverter_cfg::e, Exception, init(), s_numberOfInstances, AlCaHLTBitMon_QueryRunRegistry::string, toString(), and cms::concurrency::xercesInitialize().

                                                                 : m_destination("any") {
    try {
      //  << "Xerces-c initialization Number "
      //   << s_numberOfInstances <<
      if (s_numberOfInstances == 0) {
        cms::concurrency::xercesInitialize();
      }
    } catch (XMLException const& e) {
      // << "Xerces-c error in initialization \n"
      //      << "Exception message is:  \n"
      //      << toString(e.getMessage()) <<
      throw cms::Exception("TrivialFileCatalog",
                           std::string("Fatal Error on edm::FileLocator:") + toString(e.getMessage()));
    }
    ++s_numberOfInstances;

    init(catUrl, fallback);

    // std::cout << m_protocols.size() << " protocols" << std::endl;
    // std::cout << m_directRules[m_protocols[0]].size() << " rules" << std::endl;
  }

edm::FileLocator::~FileLocator

(

)

Definition at line 67 of file FileLocator.cc.

{}

Member Function Documentation

std::string edm::FileLocator::applyRules ( ProtocolRules const &  protocolRules, std::string const &  protocol, std::string const &  destination, bool  direct, std::string  name  ) const

private

Definition at line 228 of file FileLocator.cc.

References mps_fire::i, dataset::name, cmsCodeRulesChecker::rules, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by convert().

                                                            {
    // std::cerr << "Calling apply rules with protocol: " << protocol << "\n destination: " << destination << "\n " << " on name " << name << std::endl;

    ProtocolRules::const_iterator const rulesIterator = protocolRules.find(protocol);
    if (rulesIterator == protocolRules.end()) {
      return "";
    }

    Rules const& rules = (*(rulesIterator)).second;

    std::smatch destinationMatches;
    std::smatch nameMatches;

    /* Look up for a matching rule*/
    for (Rules::const_iterator i = rules.begin(); i != rules.end(); ++i) {
      if (!std::regex_match(destination, destinationMatches, i->destinationMatch)) {
        continue;
      }

      if (!std::regex_match(name, i->pathMatch)) {
        continue;
      }

      // std::cerr << "Rule " << i->pathMatch << "matched! " << std::endl;

      std::string const chain = i->chain;
      if ((direct == true) && (!chain.empty())) {
        name = applyRules(protocolRules, chain, destination, direct, name);
        if (name.empty()) {
          return "";
        }
      }

      std::regex_match(name, nameMatches, i->pathMatch);
      name = replaceWithRegexp(nameMatches, i->result);

      if ((direct == false) && (!chain.empty())) {
        name = applyRules(protocolRules, chain, destination, direct, name);
      }
      return name;
    }
    return "";
  }

std::string edm::FileLocator::convert ( std::string const &  input, ProtocolRules const &  rules, bool  direct  ) const

private

Definition at line 73 of file FileLocator.cc.

References applyRules(), m_destination, m_protocols, MillePedeFileConverter_cfg::out, pi, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by lfn(), and pfn().

                                                                                                      {
    std::string out = "";

    for (size_t pi = 0, pe = m_protocols.size(); pi != pe; ++pi) {
      out = applyRules(rules, m_protocols[pi], m_destination, direct, input);
      if (!out.empty())
        return out;
    }
    return out;
  }

void edm::FileLocator::init ( std::string const &  catUrl, bool  fallback  )

private

Definition at line 112 of file FileLocator.cc.

References findQualityFiles::comma, cms::xerces::cStr(), common_cff::doc, MillePedeFileConverter_cfg::e, Exception, mps_fire::i, edm::Service< T >::isAvailable(), m_destination, m_directRules, m_filename, m_inverseRules, m_protocols, TSGForRoadSearch_cfi::option, writedatasetfile::parser, parseRule(), cmsCodeRulesChecker::rules, split, AlCaHLTBitMon_QueryRunRegistry::string, and cms::xerces::uStr().

Referenced by FileLocator().

                                                               {
    std::string m_url = catUrl;

    if (m_url.empty()) {
      Service<SiteLocalConfig> localconfservice;
      if (!localconfservice.isAvailable())
        throw cms::Exception("TrivialFileCatalog", "edm::SiteLocalConfigService is not available");

      m_url = (fallback ? localconfservice->fallbackDataCatalog() : localconfservice->dataCatalog());
    }

    // std::cout << "Connecting to the catalog " << m_url << std::endl;

    if (m_url.find("file:") == std::string::npos) {
      throw cms::Exception("TrivialFileCatalog",
                           "TrivialFileCatalog::connect: Malformed url for file catalog configuration");
    }

    m_url = m_url.erase(0, m_url.find(":") + 1);

    std::vector<std::string> tokens;
    boost::algorithm::split(tokens, m_url, boost::is_any_of(std::string("?")));
    m_filename = tokens[0];

    if (tokens.size() == 2) {
      std::string const options = tokens[1];
      std::vector<std::string> optionTokens;
      boost::algorithm::split(optionTokens, options, boost::is_any_of(std::string("&")));

      std::string const equalSign("=");
      std::string const comma(",");

      for (size_t oi = 0, oe = optionTokens.size(); oi != oe; ++oi) {
        std::string const option = optionTokens[oi];
        std::vector<std::string> argTokens;
        boost::algorithm::split(argTokens, option, boost::is_any_of(equalSign));

        if (argTokens.size() != 2) {
          throw cms::Exception("TrivialFileCatalog",
                               "TrivialFileCatalog::connect: Malformed url for file catalog configuration");
        }

        if (argTokens[0] == "protocol") {
          boost::algorithm::split(m_protocols, argTokens[1], boost::is_any_of(comma));
        } else if (argTokens[0] == "destination") {
          m_destination = argTokens[1];
        }
      }
    }

    if (m_protocols.empty()) {
      throw cms::Exception("TrivialFileCatalog",
                           "TrivialFileCatalog::connect: protocol was not supplied in the contact string");
    }

    std::ifstream configFile;
    configFile.open(m_filename.c_str());

    //
    // std::cout << "Using catalog configuration " << m_filename << std::endl;

    if (!configFile.good() || !configFile.is_open()) {
      throw cms::Exception("TrivialFileCatalog",
                           "TrivialFileCatalog::connect: Unable to open trivial file catalog " + m_filename);
    }

    configFile.close();

    auto parser = std::make_unique<XercesDOMParser>();
    try {
      parser->setValidationScheme(XercesDOMParser::Val_Auto);
      parser->setDoNamespaces(false);
      parser->parse(m_filename.c_str());
      DOMDocument* doc = parser->getDocument();
      assert(doc);

      /* trivialFileCatalog matches the following xml schema
     FIXME: write a proper DTD
     <storage-mapping>
     <lfn-to-pfn protocol="direct" destination-match=".*"
     path-match="lfn/guid match regular expression"
     result="/castor/cern.ch/cms/$1"/>
     <pfn-to-lfn protocol="srm"
     path-match="lfn/guid match regular expression"
     result="$1"/>
     </storage-mapping>
      */

      /*first of all do the lfn-to-pfn bit*/
      {
        DOMNodeList* rules = doc->getElementsByTagName(uStr("lfn-to-pfn").ptr());
        XMLSize_t const ruleTagsNum = rules->getLength();

        // FIXME: we should probably use a DTD for checking validity

        for (XMLSize_t i = 0; i < ruleTagsNum; ++i) {
          DOMNode* ruleNode = rules->item(i);
          parseRule(ruleNode, m_directRules);
        }
      }
      /*Then we handle the pfn-to-lfn bit*/
      {
        DOMNodeList* rules = doc->getElementsByTagName(uStr("pfn-to-lfn").ptr());
        XMLSize_t ruleTagsNum = rules->getLength();

        for (XMLSize_t i = 0; i < ruleTagsNum; ++i) {
          DOMNode* ruleNode = rules->item(i);
          parseRule(ruleNode, m_inverseRules);
        }
      }
    } catch (xercesc::DOMException const& e) {
      throw cms::Exception("TrivialFileCatalog")
          << "Xerces XML parser threw this exception: " << cStr(e.getMessage()).ptr() << std::endl;
    }
  }

std::string edm::FileLocator::lfn

(

std::string const &

ipfn

)

const

Definition at line 71 of file FileLocator.cc.

References convert(), and m_inverseRules.

{ return convert(ipfn, m_inverseRules, false); }

void edm::FileLocator::parseRule ( xercesc::DOMNode *  ruleNode, ProtocolRules &  rules  )

private

Definition at line 84 of file FileLocator.cc.

References Exception, edm::FileLocator::Rule::pathMatch, mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, toString(), and cms::xerces::uStr().

Referenced by init().

                                                                     {
    if (!ruleNode) {
      throw cms::Exception("TrivialFileCatalog", std::string("TrivialFileCatalog::connect: Malformed trivial catalog"));
    }

    // ruleNode is actually always a DOMElement because it's the result of
    // a `getElementsByTagName()` in the calling method.
    DOMElement* ruleElement = static_cast<DOMElement*>(ruleNode);

    std::string const protocol = toString(ruleElement->getAttribute(uStr("protocol").ptr()));
    std::string destinationMatchRegexp = toString(ruleElement->getAttribute(uStr("destination-match").ptr()));

    if (destinationMatchRegexp.empty()) {
      destinationMatchRegexp = ".*";
    }

    std::string const pathMatchRegexp = toString(ruleElement->getAttribute(uStr("path-match").ptr()));
    std::string const result = toString(ruleElement->getAttribute(uStr("result").ptr()));
    std::string const chain = toString(ruleElement->getAttribute(uStr("chain").ptr()));

    Rule rule;
    rule.pathMatch.assign(pathMatchRegexp);
    rule.destinationMatch.assign(destinationMatchRegexp);
    rule.result = result;
    rule.chain = chain;
    rules[protocol].push_back(rule);
  }

std::string edm::FileLocator::pfn

(

std::string const &

ilfn

)

const

Definition at line 69 of file FileLocator.cc.

References convert(), and m_directRules.

{ return convert(ilfn, m_directRules, true); }

Member Data Documentation

std::string edm::FileLocator::m_destination

private

Definition at line 57 of file FileLocator.h.

Referenced by convert(), and init().

ProtocolRules edm::FileLocator::m_directRules

private

Direct rules are used to do the mapping from LFN to PFN.

Definition at line 50 of file FileLocator.h.

Referenced by init(), and pfn().

std::string edm::FileLocator::m_filename

private

Definition at line 55 of file FileLocator.h.

Referenced by init().

std::string edm::FileLocator::m_fileType

private

Definition at line 54 of file FileLocator.h.

ProtocolRules edm::FileLocator::m_inverseRules

private

Inverse rules are used to do the mapping from PFN to LFN

Definition at line 52 of file FileLocator.h.

Referenced by init(), and lfn().

std::vector<std::string> edm::FileLocator::m_protocols

private

Definition at line 56 of file FileLocator.h.

Referenced by convert(), and init().

int edm::FileLocator::s_numberOfInstances = 0

staticprivate

For the time being the only allowed configuration item is a prefix to be added to the GUID/LFN.

Definition at line 25 of file FileLocator.h.

Referenced by FileLocator().