Wirtual Installation Script

curl -L https://install.rlhub.dev/install.sh | sh

#!/bin/sh
set -eu#!/bin/sh
set -eu

# Wirtual's automatic install script.
# See https://github.com/wirtualdev/wirtualdev#install
#
# To run:
# curl -L https://rlhub.dev/install.sh | sh

usage() {
	arg0="$0"
	if [ "$0" = sh ]; then
		arg0="curl -fsSL https://rlhub.dev/install.sh | sh -s --"
	else
		not_curl_usage="The latest script is available at https://rlhub.dev/install.sh
"
	fi

	cath <
      Sets the prefix used by standalone release archives. Defaults to /usr/local
      and the binary is copied into /usr/local/bin
      To install in \$HOME, pass --prefix=\$HOME/.local

  --binary-name 
	  Sets the name for the CLI in standalone release archives. Defaults to "wirtual"
	  To use the CLI as wirtual2, pass --binary-name=wirtual2
	  Note: in-product documentation will always refer to the CLI as "wirtual"

  --rsh 
      Specifies the remote shell for remote installation. Defaults to ssh.

  --with-terraform
	  Installs Terraform binary from https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/ source
	  alongside wirtual.
	  This is great for if you are having issues with Wirtual installing terraform, or if you
	  just want it on your base system aswell.
	  This supports most systems, however if you are unsure yours is supported you can check
	  the link above.
  --net-admin
	  Adds \`CAP_NET_ADMIN\` to the installed binary. This allows Wirtual to
	  increase network speeds, but has security implications.
	  See: https://man7.org/linux/man-pages/man7/capabilities.7.html
	  This only works on Linux based systems.


The detection method works as follows:
  - Debian, Ubuntu, Raspbian: install the deb package from GitHub.
  - Fedora, CentOS, RHEL, openSUSE: install the rpm package from GitHub.
  - Alpine: install the apk package from GitHub.
  - macOS:  if \`brew\` is available, install from the wirtual/wirtual Homebrew tap.
  - Otherwise, download from GitHub and install into \`--prefix\`.

We build releases on GitHub for amd64, armv7, and arm64 on Windows, Linux, and macOS.

When the detection method tries to pull a release from GitHub it will
fall back to installing standalone when there is no matching release for
the system's operating system and architecture.

The installer will cache all downloaded assets into ~/.cache/wirtual
EOF
}

echo_latest_stable_version() {
	url="https://github.com/wirtualdev/wirtualdev/releases/latest"
	# https://gist.github.com/lukechilds/a83e1d7127b78fef38c2914c4ececc3c#gistcomment-2758860
	response=$(curl -sSLI -o /dev/null -w "\n%{http_code} %{url_effective}" ${url})
	status_code=$(echo "$response" | tail -n1 | cut -d' ' -f1)
	version=$(echo "$response" | tail -n1 | cut -d' ' -f2-)
	body=$(echo "$response" | sed '$d')

	if [ "$status_code" != "200" ]; then
		echoerr "GitHub API returned status code: ${status_code}"
		echoerr "URL: ${url}"
		exit 1
	fi

	version="${version#https://github.com/wirtual/wirtualdev/releases/tag/v}"
	echo "${version}"
}

echo_latest_mainline_version() {
	# Fetch the releases from the GitHub API, sort by version number,
	# and take the first result. Note that we're sorting by space-
	# separated numbers and without utilizing the sort -V flag for the
	# best compatibility.
	url="https://api.github.com/repos/wirtualdev/wirtualdev/releases"
	response=$(curl -sSL -w "\n%{http_code}" ${url})
	status_code=$(echo "$response" | tail -n1)
	body=$(echo "$response" | sed '$d')

	if [ "$status_code" != "200" ]; then
		echoerr "GitHub API returned status code: ${status_code}"
		echoerr "URL: ${url}"
		echoerr "Response body: ${body}"
		exit 1
	fi

	echo "$body" |
		awk -F'"' '/"tag_name"/ {print $4}' |
		tr -d v |
		tr . ' ' |
		sort -k1,1nr -k2,2nr -k3,3nr |
		head -n1 |
		tr ' ' .
}

echo_standalone_postinstall() {
	if [ "${DRY_RUN-}" ]; then
		echo_dryrun_postinstall
		return
	fi

	channel=
	advisory="To install our stable release (v${STABLE_VERSION}), use the --stable flag. "
	if [ "${STABLE}" = 1 ]; then
		channel="stable "
		advisory=""
	fi
	if [ "${MAINLINE}" = 1 ]; then
		channel="mainline "
	fi

	cath <

EOF
	fi
}

echo_brew_postinstall() {
	if [ "${DRY_RUN-}" ]; then
		echo_dryrun_postinstall
		return
	fi

	BREW_PREFIX="$(brew --prefix)"

	cath <

EOF
}

echo_systemd_postinstall() {
	if [ "${DRY_RUN-}" ]; then
		echo_dryrun_postinstall
		return
	fi

	echoh
	cath <

EOF
}

echo_dryrun_postinstall() {
	cath </dev/null || true

	sh_c="sh_c"
	if [ ! -w "$TERRAFORM_INSTALL_PREFIX" ]; then
		sh_c="sudo_sh_c"
	fi
	# Prepare /usr/local/bin/ and the binary for copying
	"$sh_c" mkdir -p "$TERRAFORM_INSTALL_PREFIX/bin"
	"$sh_c" unzip -d "$CACHE_DIR" -o "$CACHE_DIR/terraform_${TERRAFORM_VERSION}_${OS}_${ARCH}.zip"
	COPY_LOCATION="$TERRAFORM_INSTALL_PREFIX/bin/terraform"

	# Remove the file if it already exists to
	# avoid https://github.com/wirtualdev/wirtualdev/issues/2086
	if [ -f "$COPY_LOCATION" ]; then
		"$sh_c" rm "$COPY_LOCATION"
	fi

	# Copy the binary to the correct location.
	"$sh_c" cp "$CACHE_DIR/terraform" "$COPY_LOCATION"
}

install_macos() {
	# If there is no `brew` binary available, just default to installing standalone
	if command_exists brew; then
		echoh "Installing wirtual with Homebrew from the wirtual/wirtual tap."
		echoh

		sh_c brew install wirtual/wirtual/wirtual

		echo_brew_postinstall
		return
	fi

	echoh "Homebrew is not available."
	echoh "Falling back to standalone installation."
	install_standalone
}

install_deb() {
	echoh "Installing v$VERSION of the $ARCH deb package from GitHub."
	echoh

	fetch "https://github.com/wirtualdev/wirtualdev/releases/download/v$VERSION/wirtual_${VERSION}_${OS}_${ARCH}.deb" \
		"$CACHE_DIR/wirtual_${VERSION}_$ARCH.deb"
	sudo_sh_c dpkg --force-confdef --force-confold -i "$CACHE_DIR/wirtual_${VERSION}_$ARCH.deb"

	echo_systemd_postinstall deb
}

install_rpm() {
	echoh "Installing v$VERSION of the $ARCH rpm package from GitHub."
	echoh

	fetch "https://github.com/wirtualdev/wirtualdev/releases/download/v$VERSION/wirtual_${VERSION}_${OS}_${ARCH}.rpm" \
		"$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.rpm"
	sudo_sh_c rpm -U "$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.rpm"

	echo_systemd_postinstall rpm
}

install_apk() {
	echoh "Installing v$VERSION of the $ARCH apk package from GitHub."
	echoh

	fetch "https://github.com/wirtualdev/wirtualdev/releases/download/v$VERSION/wirtual_${VERSION}_${OS}_${ARCH}.apk" \
		"$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.apk"
	sudo_sh_c apk add --allow-untrusted "$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.apk"

	echo_systemd_postinstall apk
}

install_standalone() {
	echoh "Installing v$VERSION of the $ARCH release from GitHub."
	echoh

	# macOS releases are packaged as .zip
	case $OS in
	darwin) STANDALONE_ARCHIVE_FORMAT=zip ;;
	*) STANDALONE_ARCHIVE_FORMAT=tar.gz ;;
	esac

	fetch "https://github.com/wirtualdev/wirtualdev/releases/download/v$VERSION/wirtual_${VERSION}_${OS}_${ARCH}.$STANDALONE_ARCHIVE_FORMAT" \
		"$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.$STANDALONE_ARCHIVE_FORMAT"

	# -w only works if the directory exists so try creating it first. If this
	# fails we can ignore the error as the -w check will then swap us to sudo.
	sh_c mkdir -p "$STANDALONE_INSTALL_PREFIX" 2>/dev/null || true

	sh_c mkdir -p "$CACHE_DIR/tmp"
	if [ "$STANDALONE_ARCHIVE_FORMAT" = tar.gz ]; then
		sh_c tar -C "$CACHE_DIR/tmp" -xzf "$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.tar.gz"
	else
		sh_c unzip -d "$CACHE_DIR/tmp" -o "$CACHE_DIR/wirtual_${VERSION}_${OS}_${ARCH}.zip"
	fi

	STANDALONE_BINARY_LOCATION="$STANDALONE_INSTALL_PREFIX/bin/$STANDALONE_BINARY_NAME"

	sh_c="sh_c"
	if [ ! -w "$STANDALONE_INSTALL_PREFIX" ]; then
		sh_c="sudo_sh_c"
	fi

	"$sh_c" mkdir -p "$STANDALONE_INSTALL_PREFIX/bin"

	# Remove the file if it already exists to
	# avoid https://github.com/wirtualdev/wirtualdev/issues/2086
	if [ -f "$STANDALONE_BINARY_LOCATION" ]; then
		"$sh_c" rm "$STANDALONE_BINARY_LOCATION"
	fi

	# Copy the binary to the correct location.
	"$sh_c" cp "$CACHE_DIR/tmp/wirtual" "$STANDALONE_BINARY_LOCATION"

	# Clean up the extracted files (note, not using sudo: $sh_c -> sh_c).
	sh_c rm -rv "$CACHE_DIR/tmp"

	echo_standalone_postinstall
}

# Determine if we have standalone releases on GitHub for the system's arch.
has_standalone() {
	case $ARCH in
	amd64) return 0 ;;
	arm64) return 0 ;;
	armv7)
		[ "$(distro)" != darwin ]
		return
		;;
	*) return 1 ;;
	esac
}

os() {
	uname="$(uname)"
	case $uname in
	Linux) echo linux ;;
	Darwin) echo darwin ;;
	FreeBSD) echo freebsd ;;
	*) echo "$uname" ;;
	esac
}

# Print the detected Linux distro, otherwise print the OS name.
#
# Example outputs:
# - darwin -> darwin
# - freebsd -> freebsd
# - ubuntu, raspbian, debian ... -> debian
# - amzn, centos, rhel, fedora, ... -> fedora
# - opensuse-{leap,tumbleweed} -> opensuse
# - alpine -> alpine
# - arch -> arch
#
# Inspired by https://github.com/docker/docker-install/blob/26ff363bcf3b3f5a00498ac43694bf1c7d9ce16c/install.sh#L111-L120.
distro() {
	if [ "$OS" = "darwin" ] || [ "$OS" = "freebsd" ]; then
		echo "$OS"
		return
	fi

	if [ -f /etc/os-release ]; then
		(
			# shellcheck disable=SC1091
			. /etc/os-release
			if [ "${ID_LIKE-}" ]; then
				for id_like in $ID_LIKE; do
					case "$id_like" in debian | fedora | opensuse)
						echo "$id_like"
						return
						;;
					esac
				done
			fi

			echo "$ID"
		)
		return
	fi
}

# Print a human-readable name for the OS/distro.
distro_name() {
	if [ "$(uname)" = "Darwin" ]; then
		echo "macOS v$(sw_vers -productVersion)"
		return
	fi

	if [ -f /etc/os-release ]; then
		(
			# shellcheck disable=SC1091
			. /etc/os-release
			echo "$PRETTY_NAME"
		)
		return
	fi

	# Prints something like: Linux 4.19.0-9-amd64
	uname -sr
}

arch() {
	uname_m=$(uname -m)
	case $uname_m in
	aarch64) echo arm64 ;;
	x86_64) echo amd64 ;;
	armv7l) echo armv7 ;;
	*) echo "$uname_m" ;;
	esac
}

# The following is to change the naming, that way people with armv7 won't receive a error
# List of binaries can be found here: https://releases.hashicorp.com/terraform/
terraform_arch() {
	uname_m=$(uname -m)
	case $uname_m in
	aarch64) echo arm64 ;;
	x86_64) echo amd64 ;;
	armv7l) echo arm ;;
	*) echo "$uname_m" ;;
	esac
}

command_exists() {
	if [ ! "$1" ]; then return 1; fi
	command -v "$@" >/dev/null
}

sh_c() {
	echoh "+ $*"
	if [ ! "${DRY_RUN-}" ]; then
		sh -c "$*"
	fi
}

sudo_sh_c() {
	if [ "$(id -u)" = 0 ]; then
		sh_c "$@"
	elif command_exists sudo; then
		sh_c "sudo $*"
	elif command_exists doas; then
		sh_c "doas $*"
	elif command_exists su; then
		sh_c "su - -c '$*'"
	else
		echoh
		echoerr "This script needs to run the following command as root."
		echoerr "  $*"
		echoerr "Please install sudo, su, or doas."
		exit 1
	fi
}

echo_cache_dir() {
	if [ "${XDG_CACHE_HOME-}" ]; then
		echo "$XDG_CACHE_HOME/wirtual"
	elif [ "${HOME-}" ]; then
		echo "$HOME/.cache/wirtual"
	else
		echo "/tmp/wirtual-cache"
	fi
}

echoh() {
	echo "$@" | humanpath
}

cath() {
	humanpath
}

echoerr() {
	echoh "$@" >&2
}

# humanpath replaces all occurrences of " $HOME" with " ~"
# and all occurrences of '"$HOME' with the literal '"$HOME'.
humanpath() {
	sed "s# $HOME# ~#g; s#\"$HOME#\"\$HOME#g"
}

# We need to make sure we exit with a non zero exit if the command fails.
# /bin/sh does not support -o pipefail unfortunately.
prefix() {
	PREFIX="$1"
	shift
	fifo="$(mktemp -d)/fifo"
	mkfifo "$fifo"
	sed -e "s#^#$PREFIX: #" "$fifo" &
	"$@" >"$fifo" 2>&1
}

main "$@"

# Wirtual's automatic install script.
[Your install.sh content will be here]