env.cc

Go to the documentation of this file.

#include "env.h"
 
#include <cstring>
#include <string>
#include <algorithm>
#include <sys/stat.h>
#include <utility>
#include <vector>
 
#include "boost/algorithm/string.hpp"
#include "boost/filesystem.hpp"
 
#include "logger.h"
#include "platform.h"
#include "pyhooks.h"
 
namespace fs = boost::filesystem;
 
namespace cyclus {
 
fs::path Env::cwd_ = fs::current_path();
 
std::string Env::instdir_ = "";
 
std::string Env::PathBase(std::string path) {
  std::string base;
  int index;
 
  index = path.rfind("/");
  base = path.substr(0, index);
  return base;
}
 
const std::string Env::GetInstallPath() {
  if (instdir_.length() > 0)
    return instdir_;
  std::array<char, PATH_MAX> buffer;
  std::string instdir;
  std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("which cyclus", "r"), pclose);
  if (!pipe) {
    throw std::runtime_error("popen() failed!");
  }
  while (fgets(buffer.data(), static_cast<int>(buffer.size()), pipe.get()) != nullptr) {
    instdir += buffer.data();
  }
  if (instdir.length() <= 0)
    instdir = "/root/.local";
  else  // This should be the '/path/to/bin/cyclus/../..' (ie '/path/to')
    instdir = fs::path(instdir).parent_path().parent_path().string();
  if (!fs::exists(instdir))
    instdir = "/root/.local";
  if (std::strlen(instdir.c_str()) < instdir.length()) {
    // This is needed to remove multiple trailing NULL bytes, which then
    // cause module lookup failure because instdir + NULL + lib will be
    // truncated to just instdir by c_str() conversion.
    instdir.resize(std::strlen(instdir.c_str()));
  }
  instdir_ = instdir;
  return instdir;
}
 
const std::string Env::GetBuildPath() {
  std::string blddir = "/cyclus/build";
  if (std::strlen(blddir.c_str()) < blddir.length()) {
    // This is needed to remove multiple trailing NULL bytes, which then
    // cause module lookup failure because blddir + NULL + lib will be
    // truncated to just blddir by c_str() conversion.
    blddir.resize(std::strlen(blddir.c_str()));
    std::cout << "resized builddir " << blddir << "\n";
  }
  return blddir;
}
 
std::string Env::GetEnv(std::string varname) {
  char* pVar = getenv(varname.c_str());
  if (pVar == NULL) {
    return "";
  }
  return pVar;
}
 
const std::string Env::EnvDelimiter() {
#if _WIN32
  return ";";
#else
  return ":";
#endif
}
 
const std::string Env::PathDelimiter() {
#if _WIN32
  return "\\";
#else
  return "/";
#endif
}
 
const std::string Env::nuc_data() {
  std::string p = GetEnv("CYCLUS_NUC_DATA");
  if (p != "" && fs::exists(p)) {
    return p;
  }
 
  p = GetInstallPath() + "/share/cyclus/cyclus_nuc_data.h5";
  if (fs::exists(p)) {
    return p;
  }
 
  p = GetBuildPath() + "/share/cyclus/cyclus_nuc_data.h5";
  if (fs::exists(p)) {
    return p;
  }
 
  throw IOError("cyclus_nuc_data.h5 not found in "
                " environment variable CYCLUS_NUC_DATA or "
                + Env::GetInstallPath() + "/share/cyclus or "
                + Env::GetBuildPath() + "/share/cyclus");
}
 
const std::string Env::rng_schema(bool flat) {
  std::string p = GetEnv("CYCLUS_RNG_SCHEMA");
  if (p != "" && fs::exists(p)) {
    return p;
  }
 
  if (flat) {
    p = GetInstallPath() + "/share/cyclus/cyclus-flat.rng.in";
    if (fs::exists(p)) {
      return p;
    }
    p = GetBuildPath() + "/share/cyclus/cyclus-flat.rng.in";
    if (fs::exists(p)) {
      return p;
    }
    throw IOError("cyclus.rng.in not found in "
                  " environment variable CYCLUS_RNG_SCHEMA or "
                  + Env::GetInstallPath() + "/share/cyclus or "
                  + Env::GetBuildPath() + "/share/cyclus");
  } else {
    p = GetInstallPath() + "/share/cyclus/cyclus.rng.in";
    if (fs::exists(p)) {
      return p;
    }
    p = GetBuildPath() + "/share/cyclus/cyclus.rng.in";
    if (fs::exists(p)) {
      return p;
    }
    throw IOError("cyclus-flat.rng.in not found in "
                  " environment variable CYCLUS_RNG_SCHEMA or "
                  + Env::GetInstallPath() + "/share/cyclus or "
                  + Env::GetBuildPath() + "/share/cyclus");
  }
}
 
const std::vector<std::string> Env::cyclus_path() {
  std::string s = GetEnv("CYCLUS_PATH");
  std::vector<std::string> strs;
  boost::split(strs, s, boost::is_any_of(EnvDelimiter()));
  strs.push_back(GetInstallPath() + "/lib/cyclus");
  strs.push_back(GetBuildPath() + "/lib/cyclus");
  return strs;
}
 
const bool Env::allow_milps() {
  char* envvar = getenv("ALLOW_MILPS");
  if (envvar == NULL) {
    return true;
  } else {
    // convert envvar to lowercase string
    std::string s = std::string(envvar);
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    return !(s == "" || s == "f" || s == "false" || s == "0");
  }
}
 
#define SHOW(X) \
  std::cout << __FILE__ << ":" << __LINE__ << ": "#X" = " << X << "\n"
 
std::string Env::FindModule(std::string path) {
  return Env::FindModule(path, std::string(""));
}
 
std::string Env::FindModule(std::string path, std::string lib) {
  boost::system::error_code errc;
  std::vector<std::string> strs = cyclus_path();
 
  for (int i = 0; i < strs.size(); ++i) {
    fs::path full = fs::path(strs[i]) / path;
    if (fs::exists(full, errc)) {
      return full.string();
    }
  }
  if (!lib.empty()) {
    std::string pymod = PyFindModule(lib);
    if (!pymod.empty()) {
      return pymod;
    }
  }
  throw IOError("No module found for path " + path);
}
 
}  // namespace cyclus