haini.sh/haini.sh

#!/bin/sh
# Fallar ante cualquier error
set -e

# Por ahora sólo soportamos x86_64
uname -m | grep -q x86_64 || exit 1

DIR="$(dirname "$(realpath "$0")")"
ROOT="$(dirname "$DIR")"
SELF="$(basename "$0")"

# Sólo se puede correr desde el directorio de Sutty
if test "$ROOT" != "$(dirname "$PWD")" && test "$ROOT" != "$PWD"; then
  echo "¡No estás corriendo dentro de una carpeta de Sutty!"
fi

# Necesitamos bubblewrap
if ! type bwrap >/dev/null 2>&1 ; then
  echo "Por favor, instala el paquete bubblewrap"
  exit 1
fi

if test $(sysctl kernel.unprivileged_userns_clone -n) -ne 1 ; then
  echo "Necesitamos configurar tu sistema, ingresa tu contraseña para correr el comando" >&2
  echo "sudo sysctl -a kernel.unprivileged_userns_clone=1"
  sudo sysctl -a kernel.unprivileged_userns_clone=1
fi

# Si estamos corriendo el comando desde la raíz de trabajo no hay que
# agregar el directorio.
if test "$ROOT" = "$PWD"; then
  WORKDIR="/Sutty"
else
  WORKDIR="/Sutty/${PWD##*/}/"
fi

# Podemos cambiar el entorno
ENTORNO=${ENTORNO:-${ROOT}/hain}

correr() {
  echo "> $1"

  mkdir -p "$ENTORNO/home"
  # migrar de versiones anteriores de hainish
  test -d "$ENTORNO$HOME" && mv "$ENTORNO$HOME" "$ENTORNO/home/suttier"

  env -i \
    TERM="$TERM" \
    USER="$USER" \
    HOME="/home/suttier" \
    HAIN_ENV=true \
    RAILS_ENV="${RAILS_ENV:-development}" \
    JEKYLL_ENV="${JEKYLL_ENV:-development}" \
    EDITOR="nano" \
    PAGER="less -niSFX" \
    bwrap \
    --die-with-parent \
    --unshare-user-try \
    --unshare-ipc \
    --unshare-uts \
    --unshare-cgroup-try \
    --bind "$ENTORNO" / \
    --bind "$ROOT" /Sutty \
    --ro-bind /etc/hosts /etc/hosts \
    --ro-bind /etc/passwd /etc/passwd \
    --ro-bind /etc/group /etc/group \
    --ro-bind /etc/resolv.conf /etc/resolv.conf \
    --ro-bind /etc/localtime /etc/localtime \
    --dev-bind /dev /dev \
    --dev-bind /sys /sys \
    --dev-bind /proc /proc \
    --dev-bind /tmp /tmp \
    --chdir "$WORKDIR" \
    /bin/sh -l -c "$1" < "${stdin:-/dev/null}"
}

generar_certificado() {
  chmod 700 "$ENTORNO/etc/ssl/private"

  ca_key="/etc/ssl/private/ca-sutty.key"
  ca_crt="/usr/local/share/ca-certificates/ca-sutty.crt"

  domain_key="/etc/ssl/private/sutty.local.key"
  domain_csr="/etc/ssl/private/sutty.local.csr"
  domain_crt="/etc/ssl/certs/sutty.local.crt"

  if test -f "$ROOT/sutty.local/domain/sutty.local.crt"; then
    SUTTY_LOCAL="$ROOT/sutty.local"

    echo "Migrando certificados de sutty.local..."

    cp "$SUTTY_LOCAL/ca/key.key" "$ENTORNO$ca_key"
    cp "$SUTTY_LOCAL/ca/crt.crt" "$ENTORNO$ca_crt"

    cp "$SUTTY_LOCAL/domain/sutty.local.key" "$ENTORNO$domain_key"
    cp "$SUTTY_LOCAL/domain/sutty.local.csr" "$ENTORNO$domain_csr"
    cp "$SUTTY_LOCAL/domain/sutty.local.crt" "$ENTORNO$domain_crt"
    return
  fi

  echo "Generando certificados..."

  correr "openssl genpkey -algorithm RSA -pass pass:sutty -out $ca_key"
  correr "openssl req -x509 -new -nodes -key $ca_key -sha256 \
    -passin pass:sutty -passout pass:sutty \
    -subj '/C=IN/ST=Cyberspace/L=Cyberspace/O=Sutty/OU=Espacio/CN=Sutty Local CA' \
    -days 3650 -out $ca_crt"

  correr "update-ca-certificates"

  correr "openssl req -nodes -newkey rsa:2048 -keyout $domain_key -out $domain_csr \
    -subj '/C=IN/ST=Cyberspace/L=Cyberspace/O=Sutty/OU=Espacio/CN=sutty.local/CN=*.sutty.local'"
  correr "openssl x509 -req -in $domain_csr \
    -CA $ca_crt -CAkey $ca_key -CAcreateserial \
    -out $domain_crt -days 3650 -sha256"

  echo "Instalando certificados..."
  if which update-ca-certificates 2>/dev/null; then
    sudo install -Dm 644 "$ENTORNO$ca_crt" /usr/share/ca-certificates/extra/sutty.crt
    sudo dpkg-reconfigure ca-certificates
    sudo update-ca-certificates
  else
    sudo trust anchor "$ENTORNO$ca_crt"
  fi
}

crear_entorno() {
  ALPINE="3.13.5"
  ALPINE_URL="https://dl-cdn.alpinelinux.org/alpine/v${ALPINE%.*}/releases/x86_64/alpine-minirootfs-${ALPINE}-x86_64.tar.gz"

  # Definir si vamos a usar wget o curl
  type wget >/dev/null 2>&1 && download="wget -O -"
  type busybox >/dev/null 2>&1 && download="busybox wget -O -"
  type curl >/dev/null 2>&1 && download="curl"

  # Si no hay ninguno de los dos, salir
  test -z "${download}" && exit 1

  # Darle permiso de lectura a otres también
  umask 022

  # Crear el directorio de trabajo
  mkdir -p "$ENTORNO"

  # Descargar y extraer Alpine
  test -f "$ENTORNO/etc/os-release" || ${download} "${ALPINE_URL}" | tar xz --directory "$ENTORNO"
  # Configurar los repositorios de Sutty
  grep -q sutty "$ENTORNO/etc/apk/repositories" || echo "https://alpine.sutty.nl/alpine/v${ALPINE%\.*}/sutty" >> "$ENTORNO/etc/apk/repositories"
  test -f "$ENTORNO/etc/apk/keys/alpine@sutty.nl-5ea884cd.rsa.pub" || wget https://alpine.sutty.nl/alpine/sutty.pub -O "$ENTORNO/etc/apk/keys/alpine@sutty.nl-5ea884cd.rsa.pub"

  # Instalar las dependencias solo si cambiaron
  if test "$ENTORNO/etc/apk/world" -ot "$DIR/packages"; then
    echo "Instalando paquetes..."
    packages="$(cat "$DIR/packages" | tr "\n" " ")"
    correr "apk add --no-cache $packages"
  fi

  # Habilitar la instalación de gemas binarias
  sed -re "s/#(@platforms = )/\1/" -i "$ENTORNO/usr/lib/ruby/2.7.0/rubygems.rb"

  # Deshabilitar el usuario de nginx
  sed -re "/user nginx/d" -i "$ENTORNO/etc/nginx/nginx.conf"

  # Crear el directorio del PID
  install -dm 755 "$ENTORNO/run/nginx"
  # Instalar la configuración
  install -m 640 "$DIR/nginx.conf" "$ENTORNO/etc/nginx/http.d/default.conf"

  # Resaltado de sintaxis en nano
  grep -q "^include " "$ENTORNO/etc/nanorc" || echo "include \"/usr/share/nano/*.nanorc\"" >> "$ENTORNO/etc/nanorc"

  # Instalar scripts
  for script in "$DIR/bin/"*; do
    install -m 755 "$script" "$ENTORNO/usr/local/bin/${script##*/}"
  done

  test -f "$ENTORNO/etc/ssl/certs/sutty.local.crt" || generar_certificado
}

DEFAULT="sh"

case $1 in
  init) echo "export PATH=$DIR:\$PATH" ; exit ;;
  serve) shift; DEFAULT=nginx ;;
  *)
    if ! type "$SELF" >/dev/null 2>&1 ; then
      echo "Tip: Inicia haini.sh con 'eval \$($0 init)' para poder ejecutar con solo 'haini.sh'" >&2
    fi
  ;;
esac

crear_entorno
stdin=/dev/stdin correr "${*:-$DEFAULT}"