You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
586 lines
16 KiB
586 lines
16 KiB
#!/bin/bash
|
|
|
|
# ===============================================
|
|
# Esse script foi desenvolvido por Lucas F.
|
|
# This script was developed by Lucas F.
|
|
#
|
|
# Novembro de 2019
|
|
# 2019, November
|
|
#
|
|
# ===============================================
|
|
|
|
# Arquivo de configuração
|
|
# Config filename
|
|
ARQ_CONF="centos.conf"
|
|
|
|
# Nome do usuário no sistema
|
|
# Sistem's username
|
|
USERNAME="centos"
|
|
|
|
# Nome do App no repositório
|
|
# Application name in repository
|
|
APP="appname"
|
|
|
|
# Nome do ambiente virtual python
|
|
# Virtual environment name
|
|
VENV=".venv"
|
|
|
|
# Nome de usuário do repositório ou grupo
|
|
# Git username or group
|
|
GIT_USER="username"
|
|
|
|
# Endereço do projeto no repositório
|
|
# Git project url
|
|
GITURL="https://repo.com/$GIT_USER/$APP.git"
|
|
|
|
# IP público ou domínio. Se deixar em branco o script vai capturar o endereço de IP com o comando hostname
|
|
# Public IP address or domain. If you leave it blank, the script'll catch the IP address with hostname command
|
|
PUB_IP=""
|
|
|
|
# Nome da pasta que está no mesmo nível do arquivo wsgi.py
|
|
# Folder name that is at the same level as wsgi.py file
|
|
WSGI_FOLDER_NAME="appdirname"
|
|
|
|
# Nome desejado para o serviço no Systemctl
|
|
# Systemctl desirable name
|
|
SERVICE="app.service"
|
|
|
|
# Descrição do serviço no Systemctl
|
|
# Systemctl service description
|
|
DESCRIPTION="Django VPS uWSGI Emperor"
|
|
|
|
# Adicionar o certificado digital na aplicação com Certbot. Escreva sim, se já possuir um domínio na internet
|
|
# Apply certbot ssl certificate, hit yes if you already have a domain
|
|
CERTBOT="no"
|
|
|
|
# Adicionar renovação do certbot no crontab. Escreva sim, apenas se já possuir um domínio na internet
|
|
# Create a renew certbot cron job, hit yes if you already have a domain
|
|
CRON_CERTBOT="no"
|
|
|
|
# Incrementar IP em ALLOWED_HOSTS caso não tenha incrementado
|
|
# Increase ALLOWED_HOSTS IP on .env file
|
|
IP_INCRE="no"
|
|
|
|
# Mensagens em Português Brasil
|
|
# PT_BR messages
|
|
PTBR="yes"
|
|
|
|
HAS_ERROS="no"
|
|
ERRORS=()
|
|
|
|
declare -A MSGS
|
|
declare -A MSG_PT
|
|
MSG_PT[errors]="Por favor verifique os seguintes erros:"
|
|
MSG_PT[before]="Antes de começarmos verifique se as variáveis estão corretas:"
|
|
MSG_PT[entry]="Digite sim ou s para continuar (sim/não): "
|
|
MSG_PT[error_root]="Você precisa executar o script como root"
|
|
MSG_PT[error_requirements]="Não encontrei o arquivo requirements.txt"
|
|
MSG_PT[error_env]="Não encontrei o arquivo .env"
|
|
MSG_PT[sugest_env]="Posso criar esse arquivo pra você?
|
|
Eu criarei com as variáveis [SECRET_KEY, ALLOWED_HOSTS, DEBUG].
|
|
Sim! vou criar uma SECRET_KEY como Django
|
|
apenas para dar sequência e testar o servidor, claro que você pode alterar depois."
|
|
MSG_PT[error_allwhost]="Não encontrei a variável ALLOWED_HOSTS, você lembrou de extrair do settings.py?"
|
|
MSG_PT[error_debug]="Não encontrei a variável DEBUG, você lembrou de extrair do settings.py?"
|
|
MSG_PT[repo]="Por favor verificar o repositório ou suas credenciais"
|
|
MSG_PT[done]="TUDO PRONTO! Só curtir!"
|
|
MSG_PT[fail]="FALHOU"
|
|
|
|
declare -A MSG_EN
|
|
MSG_EN[errors]="Please check this errors:"
|
|
MSG_EN[before]="Please check the variables before starting:"
|
|
MSG_EN[entry]="Shall we proceed? (yes/no): "
|
|
MSG_EN[error_root]="You must be root"
|
|
MSG_EN[error_req]="Can't find requirements.txt file"
|
|
MSG_EN[error_env]="Can't find .env file"
|
|
MSG_EN[sugest_env]="Can i create this file for you?
|
|
I'll create basic variables like [SECRET_KEY, ALLOWED_HOSTS, DEBUG].
|
|
Yep! i'll create a SECRET_KEY like Django
|
|
just for continue and test server, although you can change it after."
|
|
MSG_EN[error_allwhost]="Can't find ALLOWED_HOSTS variable did you extract it from settings.py?"
|
|
MSG_EN[error_debug]="Can't find DEBUG variable did you extract it from settings.py?"
|
|
MSG_EN[repo]="Please check your repo or credentials"
|
|
MSG_EN[done]="ALL DONE! Enjoy it!"
|
|
MSG_EN[fail]="FAIL"
|
|
|
|
STEP=0
|
|
SCRIPT_PATH=$(dirname $0)
|
|
SCRIPT_STEP_FILE="$SCRIPT_PATH/centos_django.step"
|
|
|
|
CHARS="abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)"
|
|
for ((i=0;i<${#CHARS};i++)); do ARRAY[$i]="${CHARS:i:1}"; done
|
|
|
|
# Cria uma sequência de 50 caracteres aleatórios
|
|
# Create 50 random chars
|
|
key_gen() {
|
|
for ((c=1; c<=50; c++)); do
|
|
KEY="$KEY${ARRAY[$((RANDOM % 50))]}"
|
|
done
|
|
echo $KEY
|
|
}
|
|
|
|
# Lê o arquivo de configuração e atualiza os valores das variáveis
|
|
# Read config file and set all variables
|
|
if [[ -f "$SCRIPT_PATH/$ARQ_CONF" ]]; then
|
|
. "$SCRIPT_PATH/$ARQ_CONF"
|
|
fi
|
|
|
|
# Lê o arquivo de passos e atualiza o valor da variável
|
|
# Read step file and update the value
|
|
if [[ -f "$SCRIPT_STEP_FILE" ]]; then
|
|
. "$SCRIPT_STEP_FILE"
|
|
fi
|
|
|
|
# Verifica se deve exibir as mensagens em português do Brasil
|
|
# Check if the language pt_br has been chosen
|
|
if [[ ${PTBR,,} == "yes" ]] || [[ ${PTBR,,} == "sim" ]]; then
|
|
for i in ${!MSG_PT[@]}; do
|
|
MSGS[$i]=${MSG_PT[$i]}
|
|
done
|
|
else
|
|
for i in ${!MSG_EN[@]}; do
|
|
MSGS[$i]=${MSG_EN[$i]}
|
|
done
|
|
fi
|
|
|
|
# Verifica se o usuário ativo é o root
|
|
# Verify if is a root user
|
|
if [[ "$EUID" -ne 0 ]];then
|
|
ERRORS+=("${MSGS[error_root]}")
|
|
echo -e "\033[31m${MSGS[error_root]}\033[0m"
|
|
exit 1
|
|
fi
|
|
|
|
# Verifica a existência do usuário no sistema
|
|
# Check if user exists
|
|
CNU=$(grep -c $USERNAME /etc/passwd)
|
|
if [[ $CNU -lt 1 ]]; then
|
|
useradd --create-home $USERNAME
|
|
fi
|
|
|
|
# Sanitiza a variável SERVICE
|
|
# Sanitize SERVICE var
|
|
if [[ ! $SERVICE =~ ".service" ]]; then
|
|
SERVICE+=".service"
|
|
fi
|
|
|
|
# Obtém o IP
|
|
# Get IP address
|
|
if [[ ! -n $PUB_IP ]]; then
|
|
PUB_IP=$(hostname -I | cut -d" " -f1)
|
|
fi
|
|
|
|
update_step_error() {
|
|
STEP="$x"
|
|
echo "STEP=$STEP" > "$SCRIPT_STEP_FILE"
|
|
exit 1
|
|
}
|
|
|
|
# Exibe todas as variáveis
|
|
# Display all variables
|
|
DISPLAY="
|
|
\033[33mUSERNAME \033[0m= \033[37m$USERNAME
|
|
\033[33mAPP \033[0m= \033[37m$APP
|
|
\033[33mVENV \033[0m= \033[37m$VENV
|
|
\033[33mGIT_USER \033[0m= \033[37m$GIT_USER
|
|
\033[33mGITURL \033[0m= \033[37m$GITURL
|
|
\033[33mPUB_IP \033[0m= \033[37m$PUB_IP
|
|
\033[33mWSGI_FOLDER_NAME \033[0m= \033[37m$WSGI_FOLDER_NAME
|
|
\033[33mSERVICE \033[0m= \033[37m$SERVICE
|
|
\033[33mDESCRIPTION \033[0m= \033[37m$DESCRIPTION
|
|
\033[33mCERTBOT \033[0m= \033[37m$CERTBOT
|
|
\033[33mCRON_CERTBOT \033[0m= \033[37m$CRON_CERTBOT
|
|
\033[33mIP_INCRE \033[0m= \033[37m$IP_INCRE
|
|
\033[0m"
|
|
|
|
# Clonar o projeto
|
|
# Clone project
|
|
clone_project() {
|
|
if ! command -v git &> /dev/null; then
|
|
yum install -y git-core
|
|
fi
|
|
|
|
git clone $GITURL "/home/$USERNAME/$APP"
|
|
|
|
if [[ $? -ge 1 ]]; then
|
|
echo -e "\033[31m${MSGS[repo]}\033[0m"
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Verifica a existência do arquivo requirements.txt
|
|
# Check for existence of requirements.txt file
|
|
validate_requirements() {
|
|
if [[ ! -f "/home/$USERNAME/$APP/requirements.txt" ]]; then
|
|
echo -e "\033[31m${MSGS[errors]}" &&
|
|
echo -e "\033[0m - \033[37m${MSGS[error_req]}\033[0m" &&
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Verifica a existência do arquivo .env
|
|
# Check for existence of .env file
|
|
validate_env() {
|
|
if [[ ! -f "/home/$USERNAME/$APP/.env" ]]; then
|
|
echo -e "\033[31m${MSGS[errors]}"
|
|
echo -e "\033[0m - \033[37m${MSGS[error_env]}\033[0m" &&
|
|
echo -e "\n${MSGS[sugest_env]}\n" &&
|
|
read -p "${MSGS[entry]}" resp_env &&
|
|
if [[ -n resp_env ]]; then
|
|
if [[ ${resp_env,,} == "sim" ]] || [[ ${resp_env,,} == "s" ]] || [[ ${resp_env,,} == "yes" ]] || [[ ${resp_env,,} == "y" ]]; then
|
|
make_env_file
|
|
else
|
|
update_step_error "$x"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Cria um arquivo .env
|
|
# Create a .env file
|
|
make_env_file() {
|
|
ENV="SECRET_KEY='$(key_gen)'\n
|
|
ALLOWED_HOSTS=localhost, 127.0.0.1\n
|
|
DEBUG=False
|
|
|
|
EMAIL_HOST=
|
|
EMAIL_PORT=
|
|
EMAIL_HOST_USER=
|
|
EMAIL_HOST_PASSWORD=
|
|
EMAIL_USE_TLS=True
|
|
DEFAULT_FROM_EMAIL=
|
|
"
|
|
$(echo -e $ENV | sed -e 's/^[ \t]*//' > /home/$USERNAME/$APP/.env)
|
|
}
|
|
|
|
# Incrementar IP em ALLOWED_HOSTS no arquivo .env caso não tenha incrementado
|
|
# Increase ALLOWED_HOSTS IP on .env file if it doesn't exist
|
|
increment_ip() {
|
|
if [[ ${IP_INCRE,,} == "sim" ]] || [[ ${IP_INCRE,,} == "yes" ]]; then
|
|
if [[ ! -n $(awk '{FS="="} /ALLOWED_HOSTS=/ {print $1}' /home/$USERNAME/$APP/.env) ]]; then
|
|
echo -e "\033[31m${MSGS[error_allwhost]}\033[0m\n"
|
|
update_step_error "$x"
|
|
fi
|
|
if [[ ! -n $(awk '{FS="="} /ALLOWED_HOSTS=/ {print $2}' /home/$USERNAME/$APP/.env) ]]; then
|
|
sed -i "/ALLOWED_HOST/ s/$/$PUB_IP,/g" /home/$USERNAME/$APP/.env
|
|
else
|
|
SUBS_IP=$(sed -n "/ALLOWED_HOSTS/p" /home/$USERNAME/$APP/.env | sed "/$PUB_IP/g")
|
|
if [[ ${#SUBS_IP} -ge 1 ]]; then
|
|
if [[ ${SUBS_IP: -1} == "," ]]; then
|
|
sed -i "/ALLOWED_HOST/ s/$/$PUB_IP,/g" /home/$USERNAME/$APP/.env
|
|
else
|
|
sed -i "/ALLOWED_HOST/ s/$/,$PUB_IP,/g" /home/$USERNAME/$APP/.env
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Muda a variável DEBUG para valor Falso
|
|
# Update DEBUG variable to False
|
|
update_debug() {
|
|
if [[ ! -n $(awk '{FS="="} /DEBUG=/ {print $1}' /home/$USERNAME/$APP/.env) ]]; then
|
|
echo -e "\033[31m${MSGS[error_debug]}\033[0m\n"
|
|
update_step_error "$x"
|
|
fi
|
|
sed -i "/DEBUG/ s/=.*/=False/g" /home/$USERNAME/$APP/.env
|
|
}
|
|
|
|
# Instala pacotes necessários
|
|
# Install required packages
|
|
install_packages() {
|
|
dnf config-manager --set-enabled crb
|
|
dnf update &&
|
|
yum -y install vim &&
|
|
yum -y install epel-release &&
|
|
yum -y install bind-utils &&
|
|
yum -y install wget &&
|
|
yum -y install python3 &&
|
|
yum -y install python3-devel &&
|
|
yum -y install gcc &&
|
|
yum -y install nginx &&
|
|
yum -y install net-tools &&
|
|
yum -y install policycoreutils-python-utils.noarch &&
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Criar o ambiente Virtual
|
|
# Create venv
|
|
create_venv() {
|
|
python3 -m venv /home/$USERNAME/$APP/$VENV
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Instalar as dependências do projeto
|
|
# Install project dependencies
|
|
install_dependencies() {
|
|
/home/$USERNAME/$APP/$VENV/bin/pip3 install --upgrade pip &&
|
|
/home/$USERNAME/$APP/$VENV/bin/pip3 install uwsgi &&
|
|
/home/$USERNAME/$APP/$VENV/bin/pip3 install -r /home/$USERNAME/$APP/requirements.txt
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Coletar arquivos estáticos, criar tabelas e criar super usuário
|
|
# Perform collectstatic, migrate and createsuperuser
|
|
execute_collec_mig_createsup() {
|
|
mkdir -p /home/$USERNAME/$APP/static &&
|
|
/home/$USERNAME/$APP/$VENV/bin/python3 /home/$USERNAME/$APP/manage.py collectstatic --noinput &&
|
|
/home/$USERNAME/$APP/$VENV/bin/python3 /home/$USERNAME/$APP/manage.py migrate
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Instala o firewall
|
|
# Install firewall
|
|
install_firewall() {
|
|
yum install -y firewalld &&
|
|
systemctl start firewalld &&
|
|
firewall-cmd --permanent --add-service=ssh
|
|
firewall-cmd --permanent --add-service=http &&
|
|
firewall-cmd --permanent --add-service=https &&
|
|
firewall-cmd --reload &&
|
|
systemctl enable firewalld
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Autorizar as portas
|
|
# Enable Ports
|
|
enable_ports() {
|
|
semanage port -m -t http_port_t -p tcp 80 &&
|
|
semanage permissive -a httpd_t &&
|
|
iptables -I INPUT -p tcp -m tcp --dport 80 -j ACCEPT
|
|
firewall-cmd --zone=public --add-port=80/tcp --permanent
|
|
firewall-cmd --reload
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Corrigir a configuração inicial do nginx
|
|
# Manage default nginx config file
|
|
manage_default_nginx_file() {
|
|
mv /etc/nginx/nginx.conf /etc/nginx/nginx.conf~ &&
|
|
cat > /etc/nginx/nginx.conf <<EOF
|
|
user nginx;
|
|
worker_processes auto;
|
|
error_log /var/log/nginx/error.log;
|
|
pid /run/nginx.pid;
|
|
|
|
|
|
include /usr/share/nginx/modules/*.conf;
|
|
|
|
events {
|
|
worker_connections 1024;
|
|
}
|
|
|
|
http {
|
|
log_format main '$remote_addr - $remote_user [$time_local] "$request" '
|
|
'$status $body_bytes_sent "$http_referer" '
|
|
'"$http_user_agent" "$http_x_forwarded_for"';
|
|
|
|
access_log /var/log/nginx/access.log main;
|
|
|
|
sendfile on;
|
|
tcp_nopush on;
|
|
tcp_nodelay on;
|
|
keepalive_timeout 65;
|
|
types_hash_max_size 2048;
|
|
|
|
include /etc/nginx/mime.types;
|
|
default_type application/octet-stream;
|
|
|
|
include /etc/nginx/conf.d/*.conf;
|
|
}
|
|
EOF
|
|
}
|
|
|
|
# Criar o arquivo de configurações do NGINX
|
|
# Create nginx config file
|
|
create_nginx_file() {
|
|
cat > /etc/nginx/conf.d/$APP.conf <<EOF
|
|
upstream django {
|
|
server unix:///home/$USERNAME/$APP/mysite.sock;
|
|
}
|
|
|
|
server {
|
|
listen 80;
|
|
server_name $PUB_IP;
|
|
charset utf-8;
|
|
client_max_body_size 75M;
|
|
location /media {
|
|
alias /home/$USERNAME/$APP/media;
|
|
}
|
|
location /static {
|
|
alias /home/$USERNAME/$APP/static;
|
|
}
|
|
location / {
|
|
uwsgi_pass django;
|
|
include /etc/nginx/uwsgi_params;
|
|
}
|
|
}
|
|
EOF
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Criar o arquivo de inicialização do uWSGI
|
|
# Create uwsgi ini file
|
|
create_uwsgi_ini_file() {
|
|
cat > /home/$USERNAME/$APP/uwsgi.ini <<EOF
|
|
[uwsgi]
|
|
chdir = /home/$USERNAME/$APP
|
|
module = $WSGI_FOLDER_NAME.wsgi
|
|
pythonpath = /home/$USERNAME/$APP/$VENV
|
|
master = true
|
|
processes = 10
|
|
socket = /home/$USERNAME/$APP/mysite.sock
|
|
vacuum = true
|
|
chmod-socket = 666
|
|
EOF
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Criar o modo Emperor do uWSGI
|
|
# Create uWSGI Emperor mode
|
|
criar_emperor_uwsgi() {
|
|
mkdir -p /etc/uwsgi/vassals &&
|
|
if [[ ! -f /etc/uwsgi/vassals/uwsgi.ini ]]; then
|
|
ln -s /home/$USERNAME/$APP/uwsgi.ini /etc/uwsgi/vassals
|
|
fi
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Cria um serviço no systemctl
|
|
# Create a systemctl service
|
|
create_service_file() {
|
|
cat > /etc/systemd/system/$SERVICE <<EOF
|
|
======
|
|
[Unit]
|
|
Description=$DESCRIPTION
|
|
After=syslog.target
|
|
|
|
[Service]
|
|
ExecStart=/usr/local/bin/$SERVICE.sh
|
|
RuntimeDirectory=uwsgi
|
|
Restart=always
|
|
KillSignal=SIGQUIT
|
|
Type=notify
|
|
StandardError=syslog
|
|
NotifyAccess=all
|
|
User=$USERNAME
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
=======
|
|
EOF
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Criar o script que executa o modo Emperor do uWSGI
|
|
# Create the script called by systemctl service
|
|
create_script_emperor() {
|
|
cat > /usr/local/bin/$SERVICE.sh <<EOF
|
|
#!/bin/bash
|
|
/home/$USERNAME/$APP/$VENV/bin/uwsgi --emperor /etc/uwsgi/vassals --uid centos --gid centos
|
|
EOF
|
|
chmod +x /usr/local/bin/$SERVICE.sh
|
|
if [[ $? -ge 1 ]]; then
|
|
update_step_error "$x"
|
|
fi
|
|
}
|
|
|
|
# Rodar o sistema
|
|
# Start service
|
|
run_service() {
|
|
chown -R $USERNAME:$USERNAME /home/$USERNAME
|
|
chmod -R 751 /home/$USERNAME &&
|
|
chmod -R 755 /home/$USERNAME/$APP &&
|
|
chmod 664 /etc/systemd/system/$SERVICE &&
|
|
systemctl daemon-reload &&
|
|
systemctl enable nginx &&
|
|
systemctl start nginx &&
|
|
systemctl enable $SERVICE &&
|
|
systemctl start $SERVICE &&
|
|
systemctl restart nginx
|
|
}
|
|
|
|
#TODO: Verificar a nova instalação do certbot
|
|
# Instalar o Certbot
|
|
# Install Certbot
|
|
certbot() {
|
|
if [ "$CERTBOT" == "sim" ]; then
|
|
wget https://dl.eff.org/certbot-auto &&
|
|
mv certbot-auto /usr/local/bin/certbot-auto &&
|
|
chown root /usr/local/bin/certbot-auto &&
|
|
chmod 755 /usr/local/bin/certbot-auto &&
|
|
/usr/local/bin/certbot-auto --nginx
|
|
fi
|
|
}
|
|
|
|
# Adicionar no crontab a renovação do certificado
|
|
# Add recursive renew on crotab
|
|
crontab_certbot() {
|
|
if [ "$CRON_CERTBOT" == "sim" ]
|
|
then
|
|
echo "0 0,12 * * * root python -c 'import random; import time; time.sleep(random.random() * 3600)' && certbot renew" | tee -a /etc/crontab > /dev/null
|
|
fi
|
|
}
|
|
|
|
declare -a commands=(
|
|
"install_packages"
|
|
"clone_project"
|
|
"validate_requirements"
|
|
"validate_env"
|
|
"increment_ip"
|
|
"update_debug"
|
|
"create_venv"
|
|
"install_dependencies"
|
|
"execute_collec_mig_createsup"
|
|
"install_firewall"
|
|
"enable_ports"
|
|
"manage_default_nginx_file"
|
|
"create_nginx_file"
|
|
"create_uwsgi_ini_file"
|
|
"criar_emperor_uwsgi"
|
|
"create_service_file"
|
|
"create_script_emperor"
|
|
"run_service"
|
|
)
|
|
|
|
REPORT=()
|
|
|
|
if [[ ${#ERRORS[@]} -ge 1 ]]; then
|
|
echo "${MSGS[errors]}"
|
|
for error in "${ERRORS[@]}"; do
|
|
echo " - $error"
|
|
done
|
|
else
|
|
echo -e "\n${MSGS[before]}\n$DISPLAY"
|
|
read -p "${MSGS[entry]} " resp
|
|
|
|
if [[ -n $resp ]]; then
|
|
if [[ ${resp,,} == "sim" ]] || [[ ${resp,,} == "s" ]] || [[ ${resp,,} == "yes" ]] || [[ ${resp,,} == "y" ]]; then
|
|
for ((x=$STEP; x<${#commands[@]};x++)); do
|
|
echo "${commands[$x]}_$x"
|
|
${commands[$x]} $x
|
|
done
|
|
echo "\033[32m${MSGS[done]}\033[0m"
|
|
fi
|
|
fi
|
|
fi
|
|
|