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() {
  // On some (most?) posix shells - notably BASH and ksh - the environment
  // variable '_' is set to the absolute path of the currently executing
  // program.  This allows us to have a somewhat platform independent way
  // of figuring out the install directory. If this fails for any reason,
  // we go back to the install directory specified at compile time.
  if (instdir_.length() > 0)
    return instdir_;
  std::string instdir = GetEnv("_");
  if (instdir.length() > 0)
    instdir = "/home/stomps/.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 = "/home/stomps/.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 = "/home/stomps/dev-cyclus/cyclus/_tmp_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 false;
  } 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