Storj Storagenode Creator

#!/bin/bash

nmbr=""
ca=""
id=""
proceed=""
directory=""
wallet=""
email=""
address=""
storage=""
porttcp=""
portudp=""
portweb=""
authtoken=""
zkoptin=""
watchtower=""
nodecount=""
#rand=$((1 + $RANDOM % 25))

GREEN='\033[1;32m'
YELLOW='\033[1;33m'
RED='\033[1;31m'
NC='\033[0m' # No Color

check_if_root(){
  if [ "$EUID" -ne 0 ]
    then
      printf "${RED}Erhöhte Nutzerrechte erforderlich!${NC}\n" && exit 1
  else
    printf "${GREEN}Benutzer ist root, Skript kann gestartet werden!${NC}\n"
  fi
}

install_essentials(){
  if apt update && apt upgrade -y>/dev/null 2>&1
    then
      if ! lsb_release
        then
          printf "${YELLOW}Installieren von lsb-release${NC}\n"
          if apt install -y lsb-release>/dev/null 2>&1
            then
              printf "${GREEN}Installation von lsb-release erfolgreich.${NC}\n"
          fi
      fi
  fi
}

check_if_debian(){
  if ! [ "$(lsb_release -i | awk '{print $3}')" = "Debian" ]
    then
      printf "${RED}Betriebssystem entspricht nicht Debian, Skript wird abgebrochen!${NC}\n" && exit 1
  else
    printf "${GREEN}Betriebssystem entspricht Debian!${NC}\n"
  fi
}

choose_node(){
  while ! [[ "$proceed" =~ ^[yYjJ]+$ ]]
    do
      nmbr=""
      while ! [[ "$nmbr" =~ ^[1-9][0-9]?$|^100$ ]]
        do
          printf "${YELLOW}Wähle Deine zu bearbeitende Storagenode aus, gib eine Zahl ein (Es muss eine Zahl > 0 und <= 100 sein!): ${NC}"
          read nmbr
      done
      printf "\n${YELLOW}Überprüfe Deine Eingaben: ${NC}\n \
      ${YELLOW}Deine zu bearbeitende Storagenode ist:${NC} Storagenode-${nmbr}\n"
      printf "${YELLOW}Fortfahren? Bestätige mit j oder y: ${NC}"
      read proceed
  done
}

check_identity_ca(){
  printf "${YELLOW}Überprüfung Identität 1/2${NC}\n"
  ca=$(grep -c BEGIN $(pwd)/storj/identity/storagenode-"$nmbr"/storagenode/ca.cert)
}

check_identity_id(){
  printf "${YELLOW}Überprüfung Identität 2/2${NC}\n"
  id=$(grep -c BEGIN $(pwd)/storj/identity/storagenode-"$nmbr"/storagenode/identity.cert)
}

set_authtoken(){
  printf "${YELLOW}Gib deinen Auth-Token für${NC} Storagenode-${nmbr} ${YELLOW}ein: ${NC}"
  read authtoken
}

set_parameters(){
  while ! [[ "$proceed" =~ ^[yYjJ]+$ ]]
    do
      printf "${YELLOW}Gib den Storj-Speicherpfpad (z.B. /mnt/storj) ein: ${NC}"
        read directory
      printf "\n${YELLOW}Gib die gewünschte Speichergröße(z.B. 2TB oder 2000GB) ein: ${NC}"
        read storage
      printf "\n${YELLOW}Gib deine Ethereum-Wallet (z.B. 0x123456...) ein: ${NC}"
        read wallet
      printf "\n${YELLOW}Gib deine E-Mail-Adresse ein: ${NC}"
        read email
      printf "\n${YELLOW}Gib deine DynDNS-Adresse (z.B. meinedomain.ddns.net) ein: ${NC}"
        read address
      printf "\n${YELLOW}Gib den gewünschten externen TCP-Port (z.B. Standardport 28967) ein: ${NC}"
        read porttcp
      printf "\n${YELLOW}Gib den gewünschten externen UDP-Port (z.B. Standardport 28967) ein: ${NC}"
        read portudp
      printf "\n${YELLOW}Gib den gewünschten Webserver-Port (z.B. Standardport 14002) ein: ${NC}"
        read portweb
      printf "\n${YELLOW}Möchtest Du zksync für deine Wallet aktivieren? (j,y/n): ${NC}"
        read zkoptin
      printf "\n${YELLOW}Möchtest Du den Storj-Watchtower (automatischer Updatedienst) installieren? (j,y/n): ${NC}"
        read watchtower

      printf "\n${YELLOW}Überprüfe Deine Eingaben: ${NC}\n \
      Der Storj-Speicherpfad (NICHT die Identität!) lautet: ${directory}\n \
      Die Storagenodekapazität beträgt: ${storage}\n \
      Die Ethereum-Wallet (= STORJ-Wallet) lautet: ${wallet}\n \
      Die E-Mail-Adresse lautet: ${email}\n \
      Der TCP-Port lautet: ${porttcp}\n \
      Der UDP-Port lautet: ${portudp}\n \
      Der Webserver-Port lautet: ${portweb}\n \
      Der Status vom zksyc-opt-in lautet: ${zkoptin}\n \
      Der Status vom Watchtower lautet: ${watchtower}\n"

      printf "${YELLOW}Fortfahren? Bestätige mit j oder y: ${NC}"
      read proceed
  done
}

install_related_packages(){
  printf "${YELLOW}Installieren von Abhängigkeiten${NC}"
  if ! apt install -y curl unzip apt-transport-https ca-certificates gnupg>/dev/null 2>&1
    then
      printf "${RED}Pakete curl, unzip, apt-transport-https, ca-certificates und gnupg konnten nicht installiert werden, Skript wird abgebrochen!${NC}\n" && exit 1
  fi
}

purge_docker(){
  printf "${YELLOW}Deinstallieren vorheriger Docker-Installationen${NC}\n"
  apt purge -y docker docker.io containerd runc docker-engine>/dev/null 2>&1
}

make_directory(){
  if find $(pwd)/storj/identity/storagenode-"$nmbr">/dev/null 2>&1
    then
      printf "${GREEN}Identity-Ordner ist bereits vorhanden!${NC}\n"
  else
    printf "${YELLOW}Identity-Ordner ist noch nicht vorhanden, Ordner wird erstellt und anschließend wird eine neue Identität berechnet.${NC}\n"
    mkdir -p $(pwd)/storj/identity/storagenode-"$nmbr"
  fi
}

create_identity(){
  printf "\n${YELLOW}Erstellung Storj-Identität${NC}\n"
  if find /usr/local/bin/identity>/dev/null 2>&1
    then
      printf "${GREEN}Identity Binary ist bereits vorhanden, fahre mit Erstellung der Identität fort.${NC}\n"
  else
    printf "${YELLOW}Identity-Binary wird heruntergalden.${NC}\n"
    if curl -L https://github.com/storj/storj/releases/latest/download/identity_linux_amd64.zip -o identity_linux_amd64.zip && unzip -o identity_linux_amd64.zip && chmod +x identity && mv identity /usr/local/bin/identity
      then
        printf "${GREEN}Identity Binary wurde erfolgreich heruntergeladen und entpackt.${NC}\n"
      else
        printf "${RED}Identity-Binary konnte nicht heruntergeladen werden, Skript wird abgebrochen!${NC}\n" && exit 1
    fi
  fi

  if identity --identity-dir $(pwd)/storj/identity/storagenode-"$nmbr" --config-dir $(pwd)/storj/identity/storagenode-"$nmbr" create storagenode
    then
      printf "${GREEN}Identität wurde erzeugt!${NC}\n"
  fi
}

authorize_identity(){
  if identity --config-dir $(pwd)/storj/identity/storagenode-"$nmbr" --identity-dir $(pwd)/storj/identity/storagenode-"$nmbr" authorize storagenode "$authtoken"
    then
      printf "${GREEN}Deine Identität für ${NC}Storagenode-${nmbr} ${GREEN}wurde authorisiert!${NC}\n"
  else
    printf "${RED}Identität konnte nicht authorisiert werden, Skript wird beendet!${NC}\n" && exit 1;
  fi
}

count_nodes(){
  nodecount="$(ls $(pwd)/storj/identity | tr '\n' ' ')"
}

add_docker_apt(){
  printf "${YELLOW}Hinzufügen des Docker-Repository${NC}\n";
  if ! find /usr/share/keyrings/docker-archive-keyring.gpg>/dev/null 2>&1
    then
      if curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
        then
          printf \
          "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
          $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list>/dev/null 2>&1
          if apt update>/dev/null 2>&1
            then
              printf "${GREEN}Docker Repositorys konnten zu apt hinzugefügt werden! ${NC}\n"
          else
            printf "${RED} Neu hinzugefügte Docker-Repositories konnten nicht aktualisiert werden, Skript wird beendet!${NC}" && exit 1
          fi
      else
        printf "${RED}Docker-GPG-Key konnnte nicht installiert werden, Skript wird abgebrochen!${NC}\n" && exit 1
      fi
  fi
}

install_docker(){
  if apt install -y docker-ce docker-ce-cli containerd.io>/dev/null 2>&1
    then
      if ! docker rm hello-world-container && docker run --name hello-world-container hello-world && docker rm hello-world-container
        then
          if ! docker run --name hello-world-container hello-world && docker rm hello-world-container
            then
              printf "${RED} Der Container \"hello-world\" konnte nicht ausgeführt werden, Skript wird abgebrochen!${NC}\n" && exit 1
          fi
      fi
  else
    printf "{RED}Pakete docker-ce, docker-ce-cli und containerd.io konnten nicht installiert werden, Skript wird abgebrochen!${NC}\n" && exit 1
  fi
}

purge_storagenode(){
  if docker stop storagenode-"$nmbr" && docker rm storagenode-"$nmbr">/dev/null 2>&1
    then
      printf "${GREEN}Das Stoppen und Entfernen der alten Storagenode war erfolgreich.${NC}\n"
  elif docker rm storagenode-"$nmbr">/dev/null 2>&1
    then
      printf "${GREEN}Das Stoppen und Entfernen der alten Storagenode war erfolgreich.${NC}\n"
  elif ! docker ps -a | grep storagenode-"$nmbr">/dev/null 2>&1
    then
      printf "${YELLOW}Alter Container nicht vorhanden, fahre fort.${NC}\n"
      return 0
  else
    printf "${RED}Alter Container konnte nicht entfernt werden, Skript wird abgebrochen!${NC}\n" && exit 1
  fi

}

pull_storagenode(){
  printf "${YELLOW}Hole Storj-Container${NC}\n"
  if docker pull storjlabs/storagenode:latest
    then
      printf "${GREEN}Installation des Container-Images \"storagenode\" war erfolgreich!${NC}\n"
  else
    printf "${RED}Installation des Container-Images \"storagenode\" war nicht erfolgreich, Skript wird abgebrochen!${NC}\n" && exit 1
  fi
}

set_udp_buffersize(){
  if grep -Fxq "net.core.rmem_max=2500000" /etc/sysctl.conf
    then
      printf "${GREEN}UDP-Buffersize ist bereits angepasst!${NC}\n"
  else
    printf "${YELLOW}Passe UDP-Buffer-Größe permanent an${NC}\n";
    printf "net.core.rmem_max=2500000" >> /etc/sysctl.conf
    sysctl -w net.core.rmem_max=2500000
  fi
}

initial_storagenode_setup(){
  printf "${YELLOW}Starten der ${NC}storagenode-${nmbr}\n"
  docker run --rm -e SETUP="true" \
    --mount type=bind,source=$(pwd)/storj/identity/storagenode-"$nmbr"/storagenode,destination=/app/identity \
    --mount type=bind,source="$directory"/,destination=/app/config \
    --name storagenode-"$nmbr" storjlabs/storagenode:latest
}

replace_config_yaml(){
  if find "$directory"/config.yaml>/dev/null 2>&1
    then
      mv "$directory"/config.yaml config.yaml.old>/dev/null 2>&1
  else
    return 0
  fi
}

set_zksync(){
  if [[ "$zkoptin" =~ ^[yYjJ]+$ ]]
    then
      if grep -Fxq "operator.wallet-features: [\"zksync\"]" "$directory"/config.yaml
        then
          printf "zksync ist bereits aktiviert!\n"
      else
        printf "Aktivieren von zksync\n"
        sed -i 's/operator.wallet-features: ""/operator.wallet-features: ["zksync"]/' "$directory"/config.yaml
      fi
  fi
}

purge_watchtower(){
  if docker stop watchtower && docker rm watchtower
    then
      printf "${GREEN}Stoppen und Entfernen des alten Watchtowers war erfolgreich!${NC}\n"
  else docker rm watchtower
    then
      printf "${GREEN}Entfernen des alten Watchtowers war erfolgreich!${NC}\n"
  fi
}

install_watchtower(){
  if [[ "$watchtower" =~ ^[yYjJ]+$ ]]
    then
      printf "${YELLOW}Installieren des Watchtowers zur automatischen Aktualisierung der Node${NC}\n"
      if docker pull storjlabs/watchtower && docker run -d --restart=always --name watchtower -v /var/run/docker.sock:/var/run/docker.sock storjlabs/watchtower "$nodecount" watchtower --stop-timeout 300s
        then
          printf "${GREEN}Der Watchtower-Container wurde erfolgreich installiert\!${NC}\n"
      else
          printf "${YELLOW}Der Watchtower-Container konnte nicht installiert werden. Fahre ohne fort.${NC}\n"
      fi
  else
    printf "${YELLOW}Der Watchtower-Container wird nicht installiert, da nicht gewünscht.${NC}\n"
  fi
}

final_storagenode_setup(){
  docker run -v -it -d --restart unless-stopped --stop-timeout 300 \
   -p "$porttcp":28967/tcp \
   -p "$portudp":28967/udp \
   -p "$portweb":14002 \
   -e WALLET="$wallet" \
   -e EMAIL="$email" \
   -e ADDRESS="$address":"$porttcp" \
   -e STORAGE="$storage" \
   --mount type=bind,source=$(pwd)/storj/identity/storagenode-"$nmbr"/storagenode,destination=/app/identity \
   --mount type=bind,source="$directory"/,destination=/app/config --name storagenode-"$nmbr" storjlabs/storagenode:latest
}

main(){
  check_if_root && install_essentials && check_if_debian && choose_node && proceed="" && set_parameters && check_identity_ca && check_identity_id

  if [ "$ca" = "2" ] && [ "$id" = "3" ]
    then
      install_related_packages && count_nodes && purge_docker; add_docker_apt && install_docker && pull_storagenode && purge_storagenode && replace_config_yaml && initial_storagenode_setup && set_zksync && purge_watchtower && install_watchtower && set_udp_buffersize && final_storagenode_setup
  else
    set_authtoken && install_related_packages && make_directory && create_identity && authorize_identity && check_identity_ca && check_identity_id && count_nodes && purge_docker; add_docker_apt && install_docker && pull_storagenode && purge_storagenode && replace_config_yaml && initial_storagenode_setup && set_zksync && purge_watchtower && install_watchtower && set_udp_buffersize && final_storagenode_setup
  fi
}

main