Database/CoolConvUtilities/src/ReplicaSorter.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// ReplicaSorter.cxx
// Richard Hawkings, 26/11/07
 
#include "ReplicaSorter.h"
#include "RelationalAccess/IDatabaseServiceDescription.h"
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <map>
 
ReplicaSorter::ReplicaSorter() :
  m_frontiergen(false) {
  readConfig();
}
 
void ReplicaSorter::sort(std::vector<
      const coral::IDatabaseServiceDescription*>& replicaSet) {
  // loop through all the offered replicas
  std::map<int,const coral::IDatabaseServiceDescription*> primap;
  for (std::vector<const coral::IDatabaseServiceDescription*>::const_iterator 
     itr=replicaSet.begin();itr!=replicaSet.end();++itr) {
    const std::string conn=(**itr).connectionString();
    // do not use SQLite files
    if (conn.find("sqlite_file")==std::string::npos) {
      // extract the server name (assuming URLs "techno://server/schema")
      std::string::size_type ipos1=conn.find("://");
      std::string::size_type ipos2=conn.find('/',ipos1+3);
      if (ipos1!=std::string::npos && ipos2!=std::string::npos) {
        const std::string_view server=std::string_view(conn).substr(ipos1+3,ipos2-ipos1-3);
        // check if this server is on list of replicas to use for domain
        // if so, add it with its associated priority
        for (ServerMap::const_iterator sitr=m_servermap.begin();
         sitr!=m_servermap.end();++sitr) {
          if (sitr->first==server) 
            primap[sitr->second]=*itr;
    }
      }
    }
  }
  // now create sorted list
  replicaSet.clear();
  for (std::map<int,const coral::IDatabaseServiceDescription*>::const_iterator 
       itr=primap.begin();itr!=primap.end();++itr) {
    replicaSet.push_back(itr->second);
    std::cout << "Allowed replica to try (priority " << itr->first 
          << ") : " << (itr->second)->connectionString() << std::endl;
  }
  if (replicaSet.empty())
    std::cout << "No matching replicas found" << std::endl;
}
 
bool ReplicaSorter::readConfig() {
  // determine the hostname from ATLAS_CONDDB, HOSTNAME or hostname -fqdn
  m_hostname="";
  const char* chost=getenv("ATLAS_CONDDB");
  if (chost) m_hostname=chost;
  if (m_hostname.empty()) {
    const char* chost=getenv("HOSTNAME");
    if (chost) m_hostname=chost;
    // check if the returned host has a .
    if (m_hostname.find('.')==std::string::npos) {
      m_hostname="unknown";
      system("hostname --fqdn > hostnamelookup.tmp");
      std::ifstream infile;
      infile.open("hostnamelookup.tmp");
      if (infile) { 
        infile >> m_hostname; 
      } else {
    m_hostname="unknown";
      }
    }
  }
  std::cout << "Using machine hostname " << m_hostname << 
    " for DB replica resolution" << std::endl;
  // check if FRONTIER_SERVER is set, if so, allow generic replicas
  const char* cfrontier=getenv("FRONTIER_SERVER");
  if (cfrontier && strcmp(cfrontier,"")!=0) {
    std::cout << "Frontier server at " << cfrontier << " will be considered"
          << std::endl;
    m_frontiergen=true;
  }
 
  // try to locate configuration file using pathresolver
  FILE* p_inp=nullptr;
  const char* datapath=getenv("DATAPATH");
  if (datapath!=nullptr) p_inp=findFile("dbreplica.config",datapath);
  if (p_inp==nullptr) {
    std::cout << "Cannot open/locate configuration file dbreplica.config" 
          << std::endl;
    return false;
  }
  // buffer for reading line
  unsigned int bufsize=999;
  char* p_buf=new char[bufsize];
  while (!feof(p_inp)) {
    char* p_line=fgets(p_buf,bufsize,p_inp);
    if (p_line!=nullptr && p_line[0]!='#') {
      std::string buf=std::string(p_line);
      std::string::size_type iofs1=0;
      // analyse based on spaces as seperator
      bool sequal=false;
      std::vector<std::string> domains;
      std::vector<std::string> servers;
      while (iofs1<buf.size()) {
        std::string::size_type iofs2=buf.find(' ',iofs1);
        // allow for trailing linefeed
        if (iofs2==std::string::npos) iofs2=buf.size()-1;
        std::string token=buf.substr(iofs1,iofs2-iofs1);
    // skip empty or space tokens
    if (!token.empty() && token!=" ") {
          if (token=="=") {
        sequal=true;
          } else if (!sequal) {
        // token is a domain name
        domains.push_back(token);
          } else {
        // token is a server name
        // only add Frontier ATLF server if FRONTIER_CLIENT set
        if (token!="ATLF" || m_frontiergen) servers.push_back(token);
          }
    }
        iofs1=iofs2+1;
      }
      // check the list of domains against the hostname to see if this
      // set of servers is appropriate
      bool useit=false;
      unsigned int bestlen=0;
      for (std::vector<std::string>::const_iterator itr=domains.begin();
       itr!=domains.end();++itr) {
        std::string::size_type len=(itr->size());
    std::string::size_type hlen=m_hostname.size();
        if (hlen>=len && *itr==m_hostname.substr(hlen-len,len)) {
      if (len>bestlen) {
        useit=true;
        bestlen=len;
      }
    }
    // for 'default' domain name, add the servers as a last resort
    // if nothing has been found so far
    if ("default"==*itr && m_servermap.empty()) {
      std::cout <<
            "No specific match for domain found - use default fallback"
            << std::endl;
      useit=true;
      bestlen=0;
    }
      }
      if (useit) {
    // assign these servers, priority based on position in list
    // and length of match of domain name
    for (unsigned int i=0;i<servers.size();++i) {
      int priority=i-100*bestlen;
      m_servermap.push_back(ServerPair(servers[i],priority));
    }
      }
    }
  }
  fclose(p_inp);
  delete [] p_buf;
  std::cout << "Total of " << m_servermap.size() << 
    " servers found for host " << m_hostname << std::endl;
  return true;
}
 
FILE* ReplicaSorter::findFile(const std::string& filename,
            const std::string& pathvar) {
  // behave like pathresolver
  std::string::size_type iofs1,iofs2,len;
  FILE* fptr=nullptr;
  iofs1=0;
  len=pathvar.size();
  std::string name;
  while (!fptr && iofs1<len) {
    iofs2=pathvar.find(':',iofs1);
    if (iofs2==std::string::npos) iofs2=len;
    name=pathvar.substr(iofs1,iofs2-iofs1);
    name+='/';
    name+=filename;
    fptr=fopen(name.c_str(),"r");
    iofs1=iofs2+1;
  }
  return fptr;
}