Skip to content

Commit

Permalink
Make setup-env.sh compatible with dash on newer Ubuntus.
Browse files Browse the repository at this point in the history
  • Loading branch information
@tgamblin
tgamblin committed Jul 1, 2019
1 parent 441401b commit 6b2accc
Showing 1 changed file with 91 additions and 53 deletions.
144 changes: 91 additions & 53 deletions share/spack/setup-env.sh
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,11 +6,11 @@

########################################################################
#
# This file is part of Spack and sets up the spack environment for
# bash and zsh. This includes dotkit support, module support, and
# it also puts spack in your path. The script also checks that
# at least module support exists, and provides suggestions if it
# doesn't. Source it like this:
# This file is part of Spack and sets up the spack environment for bash,
# zsh, and dash (sh). This includes dotkit support, module support, and
# it also puts spack in your path. The script also checks that at least
# module support exists, and provides suggestions if it doesn't. Source
# it like this:
#
# . /path/to/spack/share/spack/setup-env.sh
#
Expand Down Expand Up @@ -39,24 +39,25 @@
# spack dotfiles.
########################################################################

function spack {
# Zsh does not do word splitting by default, this enables it for this function only
spack() {
# Zsh does not do word splitting by default, this enables it for this
# function only
if [ -n "${ZSH_VERSION:-}" ]; then
emulate -L sh
fi

# save raw arguments into an array before butchering them
args=( "$@" )

# accumulate initial flags for main spack command
_sp_flags=""
while [[ "$1" =~ ^- ]]; do
while [ "${1#-}" != "${1}" ]; do
_sp_flags="$_sp_flags $1"
shift
done

# h and V flags don't require further output parsing.
if [[ (! -z "$_sp_flags") && ("$_sp_flags" =~ '.*h.*' || "$_sp_flags" =~ '.*V.*') ]]; then
if [ -n "$_sp_flags" ] && \
[ "${_sp_flags#*h}" != "${_sp_flags}" ] || \
[ "${_sp_flags#*V}" != "${_sp_flags}" ];
then
command spack $_sp_flags "$@"
return
fi
Expand All @@ -66,7 +67,6 @@ function spack {
_sp_subcommand="$1"
shift
fi
_sp_spec=("$@")

# Filter out use and unuse. For any other commands, just run the
# command.
Expand All @@ -77,11 +77,11 @@ function spack {
_sp_arg="$1"
shift
fi
if [[ "$_sp_arg" = "-h" || "$_sp_arg" = "--help" ]]; then
if [ "$_sp_arg" = "-h" ] || [ "$_sp_arg" = "--help" ]; then
command spack cd -h
else
LOC="$(spack location $_sp_arg "$@")"
if [[ -d "$LOC" ]] ; then
if [ -d "$LOC" ] ; then
cd "$LOC"
else
return 1
Expand All @@ -96,13 +96,17 @@ function spack {
shift
fi

if [[ "$_sp_arg" = "-h" || "$_sp_arg" = "--help" ]]; then
if [ "$_sp_arg" = "-h" ] || [ "$_sp_arg" = "--help" ]; then
command spack env -h
else
case $_sp_arg in
activate)
_a="$@"
if [ -z "$1" -o "${_a#*--sh}" != "$_a" -o "${_a#*--csh}" != "$_a" -o "${_a#*-h}" != "$_a" ]; then
if [ -z "$1" ] || \
[ "${_a#*--sh}" != "$_a" ] || \
[ "${_a#*--csh}" != "$_a" ] || \
[ "${_a#*-h}" != "$_a" ];
then
# no args or args contain -h/--help, --sh, or --csh: just execute
command spack "${args[@]}"
else
Expand Down Expand Up @@ -130,60 +134,61 @@ function spack {
# Shift any other args for use off before parsing spec.
_sp_subcommand_args=""
_sp_module_args=""
while [[ "$1" =~ ^- ]]; do
if [ "$1" = "-r" -o "$1" = "--dependencies" ]; then
while [ "${1#-}" != "${1}" ]; do
if [ "$1" = "-r" ] || \
[ "$1" = "--dependencies" ];
then
_sp_subcommand_args="$_sp_subcommand_args $1"
else
_sp_module_args="$_sp_module_args $1"
fi
shift
done

_sp_spec=("$@")

# Here the user has run use or unuse with a spec. Find a matching
# spec using 'spack module find', then use the appropriate module
# tool's commands to add/remove the result from the environment.
# If spack module command comes back with an error, do nothing.
case $_sp_subcommand in
"use")
if _sp_full_spec=$(command spack $_sp_flags module dotkit find $_sp_subcommand_args "${_sp_spec[@]}"); then
if _sp_full_spec=$(command spack $_sp_flags module dotkit find $_sp_subcommand_args "$@"); then
use $_sp_module_args $_sp_full_spec
else
$(exit 1)
fi ;;
"unuse")
if _sp_full_spec=$(command spack $_sp_flags module dotkit find $_sp_subcommand_args "${_sp_spec[@]}"); then
if _sp_full_spec=$(command spack $_sp_flags module dotkit find $_sp_subcommand_args "$@"); then
unuse $_sp_module_args $_sp_full_spec
else
$(exit 1)
fi ;;
"load")
if _sp_full_spec=$(command spack $_sp_flags module tcl find $_sp_subcommand_args "${_sp_spec[@]}"); then
if _sp_full_spec=$(command spack $_sp_flags module tcl find $_sp_subcommand_args "$@"); then
module load $_sp_module_args $_sp_full_spec
else
$(exit 1)
fi ;;
"unload")
if _sp_full_spec=$(command spack $_sp_flags module tcl find $_sp_subcommand_args "${_sp_spec[@]}"); then
if _sp_full_spec=$(command spack $_sp_flags module tcl find $_sp_subcommand_args "$@"); then
module unload $_sp_module_args $_sp_full_spec
else
$(exit 1)
fi ;;
esac
;;
*)
command spack "${args[@]}"
command spack $_sp_flags $_sp_subcommand "$@"
;;
esac
}


########################################################################
# Prepends directories to path, if they exist.
# pathadd /path/to/dir # add to PATH
# or pathadd OTHERPATH /path/to/dir # add to OTHERPATH
########################################################################
function _spack_pathadd {
_spack_pathadd() {
# If no variable name is supplied, just append to PATH
# otherwise append to that variable.
_pa_varname=PATH
Expand All @@ -196,7 +201,10 @@ function _spack_pathadd {
# Do the actual prepending here.
eval "_pa_oldvalue=\${${_pa_varname}:-}"

if [ -d "$_pa_new_path" ] && [[ ":$_pa_oldvalue:" != *":$_pa_new_path:"* ]]; then
_pa_canonical=":$_pa_oldvalue:"
if [ -d "$_pa_new_path" ] && \
[ "${_pa_canonical#*:${_pa_new_path}:}" != *"${_pa_canonical}" ];
then
if [ -n "$_pa_oldvalue" ]; then
eval "export $_pa_varname=\"$_pa_new_path:$_pa_oldvalue\""
else
Expand All @@ -205,29 +213,11 @@ function _spack_pathadd {
fi
}

# Export spack function so it is available in subshells (only works with bash)
if [ -n "${BASH_VERSION:-}" ]; then
export -f spack
fi

#
# Figure out where this file is. Below code needs to be portable to
# bash and zsh.
#
_sp_source_file="${BASH_SOURCE[0]:-}" # Bash's location of last sourced file.
if [ -z "$_sp_source_file" ]; then
_sp_source_file="${(%):-%N}" # zsh way to do it
if [ -z "$_sp_source_file" ]; then
# Not zsh either... bail out with plain old $0,
# which WILL NOT work if this is sourced indirectly.
_sp_source_file="$0"
fi
fi

#
# Determine which shell is being used
#
function _spack_determine_shell() {
_spack_determine_shell() {
# This logic is derived from the cea-hpc/modules profile.sh example at
# https://github.com/cea-hpc/modules/blob/master/init/profile.sh.in
#
Expand All @@ -243,21 +233,69 @@ function _spack_determine_shell() {
}
export SPACK_SHELL=$(_spack_determine_shell)


# Export spack function so it is available in subshells (only works with bash)
if [ "$SPACK_SHELL" = bash ]; then
export -f spack
fi

#
# Figure out where this file is.
#
if [ "$SPACK_SHELL" = bash ]; then
_sp_source_file="${BASH_SOURCE[0]:-}"
elif [ "$SPACK_SHELL" = zsh ]; then
_sp_source_file="${(%):-%N}"
else
# Try to read the /proc filesystem (works on linux without lsof)
# In dash, the sourced file is the last one opened (and it's kept open)
_sp_source_file_fd="$(\ls /proc/$$/fd 2>/dev/null | sort -n | tail -1)"
if ! _sp_source_file="$(readlink /proc/$$/fd/$_sp_source_file_fd)"; then
# Last resort: try lsof. This works in dash on macos -- same reason.
# macos has lsof installed by default; some linux containers don't.
_sp_lsof_output="$(lsof -p $$ -Fn0 | tail -1)"
_sp_source_file="${_sp_lsof_output#*n}"
fi

# If we can't find this script's path after all that, bail out with
# plain old $0, which WILL NOT work if this is sourced indirectly.
if [ ! -f "$_sp_source_file" ]; then
_sp_source_file="$0"
fi
fi

#
# Find root directory and add bin to path.
#
# We send cd output to /dev/null to avoid because a lot of users set up
# their shell so that cd prints things out to the tty.
#
_sp_share_dir="$(cd "$(dirname $_sp_source_file)" > /dev/null && pwd)"
_sp_prefix="$(cd "$(dirname $(dirname $_sp_share_dir))" > /dev/null && pwd)"
if [ -x "$_sp_prefix/bin/spack" ]; then
export SPACK_ROOT="${_sp_prefix}"
else
# If the shell couldn't find the sourced script, fall back to
# whatever the user set SPACK_ROOT to.
if [ -n "$SPACK_ROOT" ]; then
_sp_prefix="$SPACK_ROOT"
_sp_share_dir="$_sp_prefix/share/spack"
fi

# If SPACK_ROOT didn't work, fail. We should need this rarely, as
# the tricks above for finding the sourced file are pretty robust.
if [ ! -x "$_sp_prefix/bin/spack" ]; then
echo "==> Error: SPACK_ROOT must point to spack's prefix when using $SPACK_SHELL"
echo "Run this with the correct prefix before sourcing setup-env.sh:"
echo " export SPACK_ROOT=</path/to/spack>"
return 1
fi
fi
_spack_pathadd PATH "${_sp_prefix%/}/bin"
export SPACK_ROOT="${_sp_prefix}"

#
# Check whether a function of the given name is defined
#
function _spack_fn_exists() {
_spack_fn_exists() {
LANG= type $1 2>&1 | grep -q 'function'
}

Expand All @@ -266,7 +304,6 @@ if ! _spack_fn_exists use && ! _spack_fn_exists module; then
need_module="yes"
fi;


#
# make available environment-modules
#
Expand All @@ -290,12 +327,13 @@ else
eval `spack --print-shell-vars sh`
fi;


#
# set module system roots
#
_sp_multi_pathadd() {
local IFS=':'
if [[ -n "${ZSH_VERSION:-}" ]]; then
if [ "$SPACK_SHELL" = zsh ]; then
setopt sh_word_split
fi
for pth in $2; do
Expand All @@ -307,6 +345,6 @@ _sp_multi_pathadd DK_NODE "$_sp_dotkit_roots"

# Add programmable tab completion for Bash
#
if [ -n "${BASH_VERSION:-}" ]; then
if [ "$SPACK_SHELL" = bash ]; then
source $_sp_share_dir/spack-completion.bash
fi

0 comments on commit 6b2accc

Please sign in to comment.