def _make_install_script(out_file, config):
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
lib_loc = os.path.join(env.system_install, "lib", "R", "site-library")
env.safe_sudo("mkdir -p %s" % lib_loc)
with settings(warn_only=True):
env.safe_sudo("chown -R %s %s" % (env.user, lib_loc))
repo_info = """
.libPaths(c("%s"))
library(methods)
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
source("%s")
""" % (lib_loc, config["cranrepo"], config["biocrepo"])
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn) {
%s
maybe.install <- function(pname) {
if (!(pname %%in%% installed.packages()))
install.fn(pname)
}
}
"""
if config.get("update_packages", True):
update_str = """
update.packages(lib.loc="%s", repos=repos, ask=FALSE)
""" % lib_loc
else:
update_str = "\n"
env.safe_append(out_file, install_fn % update_str)
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc", [])) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
if config.get("cran-after-bioc"):
std2_install = """
std2.pkgs <- c(%s)
lapply(std2.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran-after-bioc']))
env.safe_append(out_file, std2_install)
def _make_install_script(out_file, config):
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
lib_loc = os.path.join(env.system_install, "lib", "R", "site-library")
env.safe_sudo("mkdir -p %s" % lib_loc)
repo_info = """
.libPaths(c("%s"))
library(methods)
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
source("%s")
""" % (lib_loc, config["cranrepo"], config["biocrepo"])
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn) {
%s
maybe.install <- function(pname) {
if (!(pname %%in%% installed.packages()))
install.fn(pname)
}
}
"""
if config.get("update_packages", True):
update_str = """
update.packages(lib.loc="%s", repos=repos, ask=FALSE)
""" % lib_loc
else:
update_str = "\n"
env.safe_append(out_file, install_fn % update_str)
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc", [])) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
if config.get("cran-after-bioc"):
std2_install = """
std2.pkgs <- c(%s)
lapply(std2.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran-after-bioc']))
env.safe_append(out_file, std2_install)
def _connect_native_packages(env, pkg_install, lib_install):
"""Connect native installed packages to local versions.
This helps setup a non-sudo environment to handle software
that needs a local version in our non-root directory tree.
"""
bin_dir = os.path.join(env.system_install, "bin")
path = env.safe_run_output("echo $PATH")
comment_line = "# CloudBioLinux PATH updates"
if not env.safe_contains(env.shell_config, comment_line):
env.safe_append(env.shell_config, "\n" + comment_line)
if bin_dir not in path and env.safe_exists(env.shell_config):
add_path = "export PATH=%s:$PATH" % bin_dir
if not env.safe_contains(env.shell_config, add_path):
env.safe_append(env.shell_config, add_path)
ldlib_path = os.path.join(env.system_install, "lib")
add_ldlibrary = "export LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH" % ldlib_path
if not env.safe_contains(env.shell_config, add_ldlibrary):
env.safe_append(env.shell_config, add_ldlibrary)
perl_export = (
"export PERL5LIB=%s/lib/perl5:%s/lib/perl5/site_perl:${PERL5LIB}" %
(env.system_install, env.system_install))
if not env.safe_contains(env.shell_config, perl_export):
env.safe_append(env.shell_config, perl_export)
if "python" in pkg_install and "python" in lib_install:
_create_local_virtualenv(env.system_install)
def _connect_native_packages(env, pkg_install, lib_install):
"""Connect native installed packages to local versions.
This helps setup a non-sudo environment to handle software
that needs a local version in our non-root directory tree.
"""
bin_dir = os.path.join(env.system_install, "bin")
path = env.safe_run_output("echo $PATH")
comment_line = "# CloudBioLinux PATH updates"
if not env.safe_contains(env.shell_config, comment_line):
env.safe_append(env.shell_config, "\n" + comment_line)
if bin_dir not in path and env.safe_exists(env.shell_config):
add_path = "export PATH=%s:$PATH" % bin_dir
if not env.safe_contains(env.shell_config, add_path):
env.safe_append(env.shell_config, add_path)
ldlib_path = os.path.join(env.system_install, "lib")
add_ldlibrary = "export LD_LIBRARY_PATH=%s:$LD_LIBRARY_PATH" % ldlib_path
if not env.safe_contains(env.shell_config, add_ldlibrary):
env.safe_append(env.shell_config, add_ldlibrary)
perl_export = ("export PERL5LIB=%s/lib/perl5:%s/lib/perl5/site_perl:${PERL5LIB}"
% (env.system_install, env.system_install))
if not env.safe_contains(env.shell_config, perl_export):
env.safe_append(env.shell_config, perl_export)
if "python" in pkg_install and "python" in lib_install:
_create_local_virtualenv(env.system_install)
def r_library_installer(config):
"""Install R libraries using CRAN and Bioconductor.
"""
# Create an Rscript file with install details.
out_file = "install_packages.R"
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
repo_info = """
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
source("%s")
""" % (config["cranrepo"], config["biocrepo"])
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn) {
update.or.install <- function(pname) {
if (pname %in% installed.packages())
update.packages(lib.loc=c(pname), repos=repos, ask=FALSE)
else
install.fn(pname)
}
}
"""
env.safe_append(out_file, install_fn)
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc", [])) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
if config.get("update_packages", True):
final_update = """
update.packages(repos=biocinstallRepos(), ask=FALSE)
update.packages(ask=FALSE)
"""
env.safe_append(out_file, final_update)
# run the script and then get rid of it
env.safe_sudo("Rscript %s" % out_file)
env.safe_run("rm -f %s" % out_file)
def _connect_native_packages(env, pkg_install, lib_install):
"""Connect native installed packages to local versions.
This helps setup a non-sudo environment to handle software
that needs a local version in our non-root directory tree.
"""
bin_dir = os.path.join(env.system_install, "bin")
exports = _get_shell_exports(env)
path = env.safe_run_output("echo $PATH")
comment_line = "# CloudBioLinux PATH updates"
if not env.safe_contains(env.shell_config, comment_line):
env.safe_append(env.shell_config, "\n" + comment_line)
if bin_dir not in path and env.safe_exists(env.shell_config):
if not env.safe_contains(env.shell_config, exports["path"]):
env.safe_append(env.shell_config, exports["path"])
if "python" in pkg_install and "python" in lib_install:
_create_local_virtualenv(env.system_install)
def r_library_installer(config):
"""Install R libraries using CRAN and Bioconductor.
"""
# Create an Rscript file with install details.
out_file = "install_packages.R"
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
lib_loc = os.path.join(env.system_install, "lib", "R", "site-library")
env.safe_sudo("mkdir -p %s" % lib_loc)
repo_info = """
.libPaths(c("%s"))
library(methods)
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
source("%s")
""" % (lib_loc, config["cranrepo"], config["biocrepo"])
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn) {
%s
maybe.install <- function(pname) {
if (!(pname %%in%% installed.packages()))
install.fn(pname)
}
}
"""
if config.get("update_packages", True):
update_str = """
update.packages(lib.loc="%s", repos=repos, ask=FALSE)
""" % lib_loc
else:
update_str = "\n"
env.safe_append(out_file, install_fn % update_str)
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc", [])) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
# run the script and then get rid of it
rscript = fabutils.find_cmd(env, "Rscript", "--version")
if rscript:
env.safe_sudo("%s %s" % (rscript, out_file))
else:
env.logger.warn("Rscript not found; skipping install of R libraries.")
env.safe_run("rm -f %s" % out_file)
def r_library_installer(config):
"""Install R libraries using CRAN and Bioconductor.
"""
# Create an Rscript file with install details.
out_file = "install_packages.R"
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
lib_loc = os.path.join(env.system_install, "lib", "R", "site-library")
env.safe_sudo("mkdir -p %s" % lib_loc)
repo_info = """
.libPaths(c("%s"))
library(methods)
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
source("%s")
""" % (lib_loc, config["cranrepo"], config["biocrepo"])
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn) {
%s
maybe.install <- function(pname) {
if (!(pname %%in%% installed.packages()))
install.fn(pname)
}
}
"""
if config.get("update_packages", True):
update_str = """
update.packages(lib.loc="%s", repos=repos, ask=FALSE)
""" % lib_loc
else:
update_str = "\n"
env.safe_append(out_file, install_fn % update_str)
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc", [])) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
# run the script and then get rid of it
rscript = fabutils.find_cmd(env, "Rscript", "--version")
if rscript:
env.safe_sudo("%s %s" % (rscript, out_file))
else:
env.logger.warn("Rscript not found; skipping install of R libraries.")
env.safe_run("rm -f %s" % out_file)
def _make_install_script(out_file, config):
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
lib_loc = os.path.join(env.system_install, "lib", "R", "site-library")
env.safe_sudo("mkdir -p %s" % lib_loc)
with settings(warn_only=True):
env.safe_sudo("chown -R %s %s" % (env.user, lib_loc))
repo_info = """
.libPaths(c("%s"))
library(methods)
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
source("%s")
""" % (lib_loc, config["cranrepo"], config["biocrepo"])
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn, pkg_name_fn) {
%s
maybe.install <- function(pname) {
check_name <- ifelse(is.null(pkg_name_fn), pname, pkg_name_fn(pname))
if (!(is.element(check_name, installed.packages()[,1])))
install.fn(pname)
}
}
"""
if config.get("update_packages", True):
update_str = """
update.packages(lib.loc="%s", repos=repos, ask=FALSE)
""" % lib_loc
else:
update_str = "\n"
env.safe_append(out_file, install_fn % update_str)
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages, NULL)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc", [])) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite, NULL)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
if config.get("cran-after-bioc"):
std2_install = """
std2.pkgs <- c(%s)
lapply(std2.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran-after-bioc']))
env.safe_append(out_file, std2_install)
if config.get("github"):
dev_install = """
library(devtools)
github.pkgs <- c(%s)
get_pkg_name <- function(orig) {
unlist(strsplit(unlist(strsplit(orig, "/"))[2], "@"))[1]
}
github_installer = repo.installer(NULL, install_github, get_pkg_name)
lapply(github.pkgs, github_installer)
""" % (", ".join('"%s"' % p for p in config['github']))
env.safe_append(out_file, dev_install)
def _make_install_script(out_file, config):
if env.safe_exists(out_file):
env.safe_run("rm -f %s" % out_file)
env.safe_run("touch %s" % out_file)
lib_loc = os.path.join(env.system_install, "lib", "R", "site-library")
env.safe_sudo("mkdir -p %s" % lib_loc)
with settings(warn_only=True):
env.safe_sudo("chown -R %s %s" % (env.user, lib_loc))
repo_info = """
.libPaths(c("%s"))
library(methods)
cran.repos <- getOption("repos")
cran.repos["CRAN" ] <- "%s"
options(repos=cran.repos)
""" % (lib_loc, config["cranrepo"])
if config.get("biocrepo"):
repo_info += """\nsource("%s")\n""" % config["biocrepo"]
env.safe_append(out_file, repo_info)
install_fn = """
repo.installer <- function(repos, install.fn, pkg_name_fn) {
%s
maybe.install <- function(pname) {
if (!is.null(pkg_name_fn)) {
pinfo <- pkg_name_fn(pname)
ipkgs <- installed.packages()[,3][pinfo["pkg"]]
if (is.na(ipkgs[pinfo["pkg"]]) || pinfo["version"] != ipkgs[pinfo["pkg"]])
try(install.fn(pinfo["pname"]))
}
else if (!(is.element(pname, installed.packages()[,1])))
install.fn(pname)
}
}
"""
if config.get("update_packages", True):
update_str = """
update.packages(lib.loc="%s", repos=repos, ask=FALSE)
""" % lib_loc
else:
update_str = "\n"
env.safe_append(out_file, install_fn % update_str)
if len(config.get("cran") or []) > 0:
std_install = """
std.pkgs <- c(%s)
std.installer = repo.installer(cran.repos, install.packages, NULL)
lapply(std.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran']))
env.safe_append(out_file, std_install)
if len(config.get("bioc") or []) > 0:
bioc_install = """
bioc.pkgs <- c(%s)
bioc.installer = repo.installer(biocinstallRepos(), biocLite, NULL)
lapply(bioc.pkgs, bioc.installer)
""" % (", ".join('"%s"' % p for p in config['bioc']))
env.safe_append(out_file, bioc_install)
if config.get("cran-after-bioc"):
std2_install = """
std2.pkgs <- c(%s)
lapply(std2.pkgs, std.installer)
""" % (", ".join('"%s"' % p for p in config['cran-after-bioc']))
env.safe_append(out_file, std2_install)
if config.get("github"):
dev_install = """
library(devtools)
github.pkgs <- c(%s)
get_pkg_name <- function(orig) {
c(pkg=unlist(strsplit(unlist(strsplit(orig, "/"))[2], "@"))[1],
version=unlist(strsplit(orig, ";"))[2],
pname=unlist(strsplit(orig, ";"))[1])
}
gh_install <- function(name) {
install_github(name, upgrade_dependencies=FALSE)
}
github_installer = repo.installer(NULL, gh_install, get_pkg_name)
lapply(github.pkgs, github_installer)
""" % (", ".join('"%s"' % p for p in config['github']))
env.safe_append(out_file, dev_install)
