#!/bin/sh set -u err() { echo "$1" >&2 exit 1 } # NOTICE: If you change anything here, please make the same changes in self_install.rs usage() { cat < The directory to locally install SpacetimeDB into. If unspecified, uses platform defaults -y, --yes Skip the confirmation dialog -h, --help Print help EOF } SPACETIME_DOWNLOAD_ROOT="${SPACETIME_DOWNLOAD_ROOT:-https://github.com/clockworklabs/SpacetimeDB/releases/latest/download}" main() { # First make sure all config is valid, we don't want to end up with # a partial install. local _downloader if check_cmd curl; then _downloader=curl elif check_cmd wget; then _downloader=wget else err "need 'curl' or 'wget' (command not found)" fi need_cmd chmod need_cmd rm need_cmd rmdir need_cmd mktemp # Detect the OS and arch get_architecture || return 1 local _host="$RETVAL" [ -z "$_host" ] && err "failed to get architecture" local _ext="" case "$_host" in *windows*) _ext=".exe" ;; esac # We can now install the binary local _tmpdir _tmpdir="$(ensure mktemp -d)" || exit 1 local _download_file="$_tmpdir/spacetime-install$_ext" check_for_help_flag "$@" # Define the latest SpacetimeDB download url local _url="$SPACETIME_DOWNLOAD_ROOT/spacetimedb-update-$_host$_ext" echo "Downloading installer..." if [ "$_downloader" = curl ]; then local _httpstatus if ! _httpstatus="$(curl -sSfL -w '%{http_code}' --progress-bar "$_url" -o "$_download_file")"; then if [ "$_httpstatus" = 404 ]; then err "It seems like we may not have prebuilt binaries for your platform." fi exit 1 fi elif [ "$_downloader" = wget ]; then wget "$_url" -O "$_download_file" || exit 1 fi ensure chmod u+x "$_download_file" if [ ! -x "$_download_file" ]; then printf '%s\n' "Cannot execute $_download_file (likely because of mounting /tmp as noexec)." 1>&2 printf '%s\n' "Please copy the file to a location where you can execute binaries and run ./spacetime-install${_ext}." 1>&2 exit 1 fi "$_download_file" "$@" local _retval=$? rm -f "$_download_file" rmdir "$_tmpdir" return "$_retval" } check_for_help_flag() { for arg in "$@"; do case "$arg" in --help) usage exit 0 ;; *) OPTIND=1 if [ "${arg%%--*}" = "" ]; then # Long option (other than --help); # don't attempt to interpret it. continue fi while getopts :hy sub_arg "$arg"; do case "$sub_arg" in h) usage exit 0 ;; *) ;; esac done ;; esac done } # The following functions are from rustup-init.sh of the Rust project: # get_architecture, get_endianness, need_cmd, check_cmd, ensure # Licensed under the MIT license: ## Copyright (c) 2016 The Rust Project Developers ## ## Permission is hereby granted, free of charge, to any ## person obtaining a copy of this software and associated ## documentation files (the "Software"), to deal in the ## Software without restriction, including without ## limitation the rights to use, copy, modify, merge, ## publish, distribute, sublicense, and/or sell copies of ## the Software, and to permit persons to whom the Software ## is furnished to do so, subject to the following ## conditions: ## ## The above copyright notice and this permission notice ## shall be included in all copies or substantial portions ## of the Software. ## ## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ## ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED ## TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A ## PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT ## SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ## CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ## OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR ## IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ## DEALINGS IN THE SOFTWARE. get_architecture() { local _ostype _cputype _bitness _arch _clibtype _ostype="$(uname -s)" _cputype="$(uname -m)" _clibtype="gnu" if [ "$_ostype" = Linux ]; then if [ "$(uname -o)" = Android ]; then _ostype=Android fi if ldd --version 2>&1 | grep -q 'musl'; then _clibtype="musl" fi fi if [ "$_ostype" = Darwin ]; then # Darwin `uname -m` can lie due to Rosetta shenanigans. If you manage to # invoke a native shell binary and then a native uname binary, you can # get the real answer, but that's hard to ensure, so instead we use # `sysctl` (which doesn't lie) to check for the actual architecture. if [ "$_cputype" = i386 ]; then # Handling i386 compatibility mode in older macOS versions (<10.15) # running on x86_64-based Macs. # Starting from 10.15, macOS explicitly bans all i386 binaries from running. # See: # Avoid `sysctl: unknown oid` stderr output and/or non-zero exit code. if sysctl hw.optional.x86_64 2> /dev/null || true | grep -q ': 1'; then _cputype=x86_64 fi elif [ "$_cputype" = x86_64 ]; then # Handling x86-64 compatibility mode (a.k.a. Rosetta 2) # in newer macOS versions (>=11) running on arm64-based Macs. # Rosetta 2 is built exclusively for x86-64 and cannot run i386 binaries. # Avoid `sysctl: unknown oid` stderr output and/or non-zero exit code. if sysctl hw.optional.arm64 2> /dev/null || true | grep -q ': 1'; then _cputype=arm64 fi fi fi if [ "$_ostype" = SunOS ]; then # Both Solaris and illumos presently announce as "SunOS" in "uname -s" # so use "uname -o" to disambiguate. We use the full path to the # system uname in case the user has coreutils uname first in PATH, # which has historically sometimes printed the wrong value here. if [ "$(/usr/bin/uname -o)" = illumos ]; then _ostype=illumos fi # illumos systems have multi-arch userlands, and "uname -m" reports the # machine hardware name; e.g., "i86pc" on both 32- and 64-bit x86 # systems. Check for the native (widest) instruction set on the # running kernel: if [ "$_cputype" = i86pc ]; then _cputype="$(isainfo -n)" fi fi case "$_ostype" in Android) _ostype=linux-android ;; Linux) check_proc _ostype=unknown-linux-$_clibtype _bitness=$(get_bitness) ;; FreeBSD) _ostype=unknown-freebsd ;; NetBSD) _ostype=unknown-netbsd ;; DragonFly) _ostype=unknown-dragonfly ;; Darwin) _ostype=apple-darwin ;; illumos) _ostype=unknown-illumos ;; MINGW* | MSYS* | CYGWIN* | Windows_NT) _ostype=pc-windows-gnu ;; *) err "unrecognized OS type: $_ostype" ;; esac case "$_cputype" in i386 | i486 | i686 | i786 | x86) _cputype=i686 ;; xscale | arm) _cputype=arm if [ "$_ostype" = "linux-android" ]; then _ostype=linux-androideabi fi ;; armv6l) _cputype=arm if [ "$_ostype" = "linux-android" ]; then _ostype=linux-androideabi else _ostype="${_ostype}eabihf" fi ;; armv7l | armv8l) _cputype=armv7 if [ "$_ostype" = "linux-android" ]; then _ostype=linux-androideabi else _ostype="${_ostype}eabihf" fi ;; aarch64 | arm64) _cputype=aarch64 ;; x86_64 | x86-64 | x64 | amd64) _cputype=x86_64 ;; mips) _cputype=$(get_endianness mips '' el) ;; mips64) if [ "$_bitness" -eq 64 ]; then # only n64 ABI is supported for now _ostype="${_ostype}abi64" _cputype=$(get_endianness mips64 '' el) fi ;; ppc) _cputype=powerpc ;; ppc64) _cputype=powerpc64 ;; ppc64le) _cputype=powerpc64le ;; s390x) _cputype=s390x ;; riscv64) _cputype=riscv64gc ;; loongarch64) _cputype=loongarch64 ensure_loongarch_uapi ;; *) err "unknown CPU type: $_cputype" esac # Detect 64-bit linux with 32-bit userland if [ "${_ostype}" = unknown-linux-gnu ] && [ "${_bitness}" -eq 32 ]; then case $_cputype in x86_64) _cputype=i686 ;; mips64) _cputype=$(get_endianness mips '' el) ;; powerpc64) _cputype=powerpc ;; aarch64) _cputype=armv7 if [ "$_ostype" = "linux-android" ]; then _ostype=linux-androideabi else _ostype="${_ostype}eabihf" fi ;; riscv64gc) err "riscv64 with 32-bit userland unsupported" ;; esac fi # Detect armv7 but without the CPU features Rust needs in that build, # and fall back to arm. # See https://github.com/rust-lang/rustup.rs/issues/587. if [ "$_ostype" = "unknown-linux-gnueabihf" ] && [ "$_cputype" = armv7 ]; then if ensure grep '^Features' /proc/cpuinfo | grep -E -q -v 'neon|simd'; then # At least one processor does not have NEON (which is asimd on armv8+). _cputype=arm fi fi _arch="${_cputype}-${_ostype}" RETVAL="$_arch" } check_proc() { # Check for /proc by looking for the /proc/self/exe link # This is only run on Linux if ! test -L /proc/self/exe ; then err "fatal: Unable to find /proc/self/exe. Is /proc mounted? Installation cannot proceed without /proc." fi } get_bitness() { need_cmd head # Architecture detection without dependencies beyond coreutils. # ELF files start out "\x7fELF", and the following byte is # 0x01 for 32-bit and # 0x02 for 64-bit. # The printf builtin on some shells like dash only supports octal # escape sequences, so we use those. local _current_exe_head _current_exe_head=$(head -c 5 /proc/self/exe ) if [ "$_current_exe_head" = "$(printf '\177ELF\001')" ]; then echo 32 elif [ "$_current_exe_head" = "$(printf '\177ELF\002')" ]; then echo 64 else err "unknown platform bitness" fi } get_endianness() { local cputype=$1 local suffix_eb=$2 local suffix_el=$3 # detect endianness without od/hexdump, like get_bitness() does. need_cmd head need_cmd tail local _current_exe_endianness _current_exe_endianness="$(head -c 6 /proc/self/exe | tail -c 1)" if [ "$_current_exe_endianness" = "$(printf '\001')" ]; then echo "${cputype}${suffix_el}" elif [ "$_current_exe_endianness" = "$(printf '\002')" ]; then echo "${cputype}${suffix_eb}" else err "unknown platform endianness" fi } need_cmd() { if ! check_cmd "$1"; then err "need '$1' (command not found)" fi } check_cmd() { command -v "$1" > /dev/null 2>&1 } # Run a command that should never fail. If the command fails execution # will immediately terminate with an error showing the failing # command. ensure() { if ! "$@"; then err "command failed: $*"; fi } main "$@" || exit 1