5392 lines
203 KiB
Bash
Executable File
5392 lines
203 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# The most recent program version.
|
|
_VERSION="3.4.6"
|
|
_V="3.4"
|
|
|
|
# The program full name
|
|
PROGRAM_NAME="Octojoom"
|
|
|
|
# Set Server Hostname
|
|
SERVER_HOSTNAME="$(hostname)"
|
|
|
|
# Set the back title
|
|
BACK_TITLE=" Octoleo | ${USER}@${SERVER_HOSTNAME}"
|
|
|
|
# make sure whiptail is installed
|
|
command -v whiptail >/dev/null 2>&1 || {
|
|
echo >&2 "ERROR: ${PROGRAM_NAME} v${_VERSION} script require whiptail."
|
|
exit 1
|
|
}
|
|
# make sure curl is installed
|
|
command -v curl >/dev/null 2>&1 || {
|
|
echo >&2 "ERROR: ${PROGRAM_NAME} v${_VERSION} script require curl."
|
|
exit 1
|
|
}
|
|
# make sure awk is installed
|
|
command -v awk >/dev/null 2>&1 || {
|
|
echo >&2 "ERROR: ${PROGRAM_NAME} v${_VERSION} script require awk."
|
|
exit 1
|
|
}
|
|
# Check if Docker is installed.
|
|
if ! command -v docker &>/dev/null; then
|
|
# If Docker is not installed, ask the user if they want to install it.
|
|
if whiptail --yesno "Docker is not installed. Do you want to install it now?" \
|
|
--backtitle "${BACK_TITLE}" 10 60; then
|
|
# If the user chooses Yes, install Docker.
|
|
echo "Installing Docker..."
|
|
|
|
# Add Docker GPG key and repository to sources.list.
|
|
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
|
|
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
|
|
|
|
# Update package index and install Docker.
|
|
sudo apt-get update
|
|
sudo apt-get install docker-ce docker-ce-cli containerd.io -y
|
|
|
|
# Add the current user to the docker group.
|
|
sudo groupadd docker
|
|
sudo usermod -aG docker "$USER"
|
|
|
|
# Enable and start the Docker service.
|
|
sudo systemctl enable docker.service
|
|
sudo systemctl start docker.service
|
|
|
|
echo "Docker is installed."
|
|
else
|
|
# If the user chooses No, exit the script with an error message.
|
|
echo >&2 "ERROR: ${PROGRAM_NAME} v${_VERSION} script require docker."
|
|
exit 1
|
|
fi
|
|
fi
|
|
# Check if Docker Compose is installed.
|
|
if ! command -v docker-compose &>/dev/null; then
|
|
# If Docker Compose is not installed, ask the user if they want to install it.
|
|
if whiptail --yesno "Docker Compose is not installed. Do you want to install it now?" \
|
|
--backtitle "${BACK_TITLE}" 10 60; then
|
|
# If the user chooses Yes, install Docker Compose.
|
|
echo "Installing Docker Compose..."
|
|
|
|
# Download the latest Docker Compose binary.
|
|
COMPOSE_VERSION=$(curl --silent https://api.github.com/repos/docker/compose/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
|
|
sudo curl -SL "https://github.com/docker/compose/releases/download/$COMPOSE_VERSION/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
|
|
|
|
# Make the Docker Compose binary executable.
|
|
sudo chmod +x /usr/local/bin/docker-compose
|
|
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
|
|
|
|
echo "Docker Compose is installed."
|
|
else
|
|
# If the user chooses No, exit the script with an error message.
|
|
echo >&2 "ERROR: ${PROGRAM_NAME} v${_VERSION} script require docker-compose."
|
|
exit 1
|
|
fi
|
|
fi
|
|
# just clear the screen
|
|
clear
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## The main method
|
|
function main() {
|
|
# we check if we have a type and a task
|
|
# we use the __TRuST__ convention AS "PUBLIC METHODS" to avoid wrong calls, and hide other functions
|
|
if [ ${#VDM_CONTAINER_TYPE} -ge 1 ] && [ ${#VDM_TASK} -ge 1 ] && isFunc "${VDM_CONTAINER_TYPE}__TRuST__${VDM_TASK}"; then
|
|
"${VDM_CONTAINER_TYPE}__TRuST__${VDM_TASK}"
|
|
else
|
|
mainMenu
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## SETUP TRAEFIK
|
|
function traefik__TRuST__setup() {
|
|
# load this container type globals
|
|
# shellcheck disable=SC1090
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && source "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# check if we have secure switch set
|
|
setSecureState
|
|
# setup letsencrypt stuff
|
|
if $VDM_SECURE; then
|
|
VDM_REMOVE_SECURE=''
|
|
VDM_HTTP_SCHEME="https"
|
|
# get the email if not set
|
|
while [ ${#VDM_SECURE_EMAIL} -le 1 ]; do
|
|
# get the value
|
|
VDM_SECURE_EMAIL=$(getInput 'Enter email for the Letsencrypt setup.' '' 'Enter Valid Email')
|
|
# keep asking
|
|
[ ${#VDM_SECURE_EMAIL} -ge 1 ] || {
|
|
showError "You must enter an email for the Letsencrypt setup."
|
|
}
|
|
done
|
|
# make sure the directory exist
|
|
mkdir -p "${VDM_PROJECT_PATH}/traefik"
|
|
# we must create this, else docker creates a folder
|
|
echo "{}" > "${VDM_PROJECT_PATH}/traefik/acme.json"
|
|
# make sure the permission are good
|
|
sudo chmod 600 "${VDM_PROJECT_PATH}/traefik/acme.json"
|
|
# and is owned by root
|
|
sudo chown -R root:root "${VDM_PROJECT_PATH}/traefik"
|
|
else
|
|
VDM_REMOVE_SECURE="#"
|
|
VDM_HTTP_SCHEME="http"
|
|
fi
|
|
# set the main domain if not set
|
|
setMainDomain
|
|
##########################
|
|
### export all we need
|
|
# global
|
|
export VDM_CONTAINER_TYPE
|
|
export VDM_REPO_PATH
|
|
export VDM_PROJECT_PATH
|
|
# container
|
|
export VDM_REMOVE_SECURE
|
|
export VDM_HTTP_SCHEME
|
|
export VDM_SECURE_EMAIL
|
|
## create the directory if it does not yet already exist
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}"
|
|
## place this docker composer file in its place
|
|
traefikContainer >"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
## set permissions
|
|
chmod 600 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
# saved the file
|
|
showNotice "Saved ${VDM_CONTAINER_TYPE}:docker-compose.yml file.\nSetup of this container is complete!"
|
|
# ask if we should continue to enable
|
|
if (whiptail --yesno "Would you also like to enable this ${VDM_CONTAINER_TYPE^} container" --defaultno \
|
|
--title "Enable Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
##########################
|
|
### unset all no longer needed
|
|
# container
|
|
unset VDM_REMOVE_SECURE
|
|
unset VDM_HTTP_SCHEME
|
|
unset VDM_SECURE_EMAIL
|
|
# return a success
|
|
return 0
|
|
}
|
|
|
|
# return the Traefik Container setup yml
|
|
function traefikContainer() {
|
|
# we build the yml file
|
|
cat <<EOF
|
|
version: "3.3"
|
|
|
|
services:
|
|
traefik:
|
|
container_name: traefik
|
|
image: "traefik:latest"
|
|
command:
|
|
${VDM_REMOVE_SECURE} - --entrypoints.web.address=:80
|
|
${VDM_REMOVE_SECURE} - --entrypoints.websecure.address=:443
|
|
# - --api.dashboard=true
|
|
# - --api.insecure=true
|
|
- --providers.docker
|
|
${VDM_REMOVE_SECURE} - --log.level=INFO
|
|
${VDM_REMOVE_SECURE} - --certificatesresolvers.vdmresolver.acme.httpchallenge=true
|
|
${VDM_REMOVE_SECURE} - --certificatesresolvers.vdmresolver.acme.keytype=RSA4096
|
|
${VDM_REMOVE_SECURE} - --certificatesresolvers.vdmresolver.acme.email=${VDM_SECURE_EMAIL:-user@demo.com}
|
|
${VDM_REMOVE_SECURE} - --certificatesresolvers.vdmresolver.acme.storage=/acme.json
|
|
${VDM_REMOVE_SECURE} - --certificatesresolvers.vdmresolver.acme.httpchallenge.entrypoint=web
|
|
${VDM_REMOVE_SECURE} - --providers.file.directory=/conf
|
|
${VDM_REMOVE_SECURE} - --providers.file.watch=true
|
|
restart: unless-stopped
|
|
ports:
|
|
- "80:80"
|
|
- "443:443"
|
|
# - "8080:8080"
|
|
volumes:
|
|
- /var/run/docker.sock:/var/run/docker.sock
|
|
${VDM_REMOVE_SECURE} - "\${VDM_PROJECT_PATH}/traefik/conf:/conf"
|
|
${VDM_REMOVE_SECURE} - "\${VDM_PROJECT_PATH}/traefik/acme.json:/acme.json"
|
|
${VDM_REMOVE_SECURE} - "\${VDM_PROJECT_PATH}/traefik/errors:/errors"
|
|
${VDM_REMOVE_SECURE} labels:
|
|
# settings for all containers
|
|
${VDM_REMOVE_SECURE} - "traefik.http.routers.http-catchall.rule=hostregexp(\`{host:.+}\`)"
|
|
${VDM_REMOVE_SECURE} - "traefik.http.routers.http-catchall.entrypoints=web"
|
|
${VDM_REMOVE_SECURE} - "traefik.http.routers.http-catchall.middlewares=redirect-to-me"
|
|
${VDM_REMOVE_SECURE} - "traefik.http.middlewares.redirect-to-me.redirectscheme.scheme=${VDM_HTTP_SCHEME}"
|
|
networks:
|
|
- traefik
|
|
|
|
networks:
|
|
traefik:
|
|
name: ${VDM_TRAEFIK_GATEWAY:-traefik_webgateway}
|
|
EOF
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## SETUP PORTAINER
|
|
function portainer__TRuST__setup() {
|
|
# load this container type globals
|
|
# shellcheck disable=SC1090
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && source "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# check if we have secure switch set
|
|
setSecureState
|
|
# setup letsencrypt stuff
|
|
VDM_PORT_SECURE_LABELS=''
|
|
if $VDM_SECURE; then
|
|
VDM_REMOVE_SECURE=''
|
|
VDM_ENTRY_POINT="websecure"
|
|
setSecureCloudflareState
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_PORT_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.portainer.entrypoints=web\"")
|
|
else
|
|
VDM_PORT_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.portainer.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_PORT_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.portainer.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
else
|
|
VDM_REMOVE_SECURE="#"
|
|
VDM_ENTRY_POINT="web"
|
|
fi
|
|
# set the domain
|
|
setDomain
|
|
# get the sub domain if not set
|
|
setSubDomain 'port' '' 'joomla'
|
|
##########################
|
|
### export all we need
|
|
# global
|
|
export VDM_CONTAINER_TYPE
|
|
export VDM_REPO_PATH
|
|
export VDM_PROJECT_PATH
|
|
# container
|
|
export VDM_REMOVE_SECURE
|
|
export VDM_ENTRY_POINT
|
|
export VDM_PORT_SECURE_LABELS
|
|
# set host file if needed
|
|
updateHostFile
|
|
## create the directory if it does not yet already exist
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}"
|
|
## place this docker composer file in its place
|
|
portainerContainer >"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
## set permissions
|
|
chmod 600 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
# saved the file
|
|
showNotice "Saved ${VDM_CONTAINER_TYPE}:docker-compose.yml file.\nSetup of this container is complete!"
|
|
# ask if we should continue to enable
|
|
if (whiptail --yesno "Would you also like to enable this ${VDM_CONTAINER_TYPE^} container" \
|
|
--defaultno --title "Enable Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
##########################
|
|
### unset all no longer needed
|
|
# container
|
|
unset VDM_SUBDOMAIN
|
|
unset VDM_REMOVE_SECURE
|
|
unset VDM_ENTRY_POINT
|
|
unset VDM_PORT_SECURE_LABELS
|
|
# return a success
|
|
return 0
|
|
}
|
|
|
|
# return the Portainer Container setup yml
|
|
function portainerContainer() {
|
|
# we build the yml file
|
|
cat <<EOF
|
|
version: "3.3"
|
|
|
|
services:
|
|
portainer:
|
|
image: portainer/portainer-ce:latest
|
|
container_name: portainer
|
|
command: -H unix:///var/run/docker.sock
|
|
restart: always
|
|
volumes:
|
|
- /var/run/docker.sock:/var/run/docker.sock
|
|
- portainer_data:/data
|
|
labels:
|
|
# Frontend
|
|
- "traefik.enable=true"
|
|
- "traefik.http.routers.portainer.rule=Host(\`${VDM_SUBDOMAIN}.${VDM_DOMAIN}\`)"${VDM_PORT_SECURE_LABELS}
|
|
- "traefik.http.routers.portainer.service=portainer"
|
|
- "traefik.http.services.portainer.loadbalancer.server.port=9000"
|
|
|
|
# Edge
|
|
# - "traefik.http.routers.portaineredge.rule=Host(\`${VDM_SUBDOMAIN}edge.${VDM_DOMAIN}\`)"
|
|
# - "traefik.http.routers.portaineredge.entrypoints=${VDM_ENTRY_POINT}"
|
|
# - "traefik.http.routers.portaineredge.tls.certresolver=vdmresolver"
|
|
# - "traefik.http.routers.portaineredge.service=portaineredge"
|
|
# - "traefik.http.services.portaineredge.loadbalancer.server.port=8000"
|
|
networks:
|
|
- traefik
|
|
|
|
volumes:
|
|
portainer_data:
|
|
|
|
networks:
|
|
traefik:
|
|
external: true
|
|
name: ${VDM_TRAEFIK_GATEWAY:-traefik_webgateway}
|
|
EOF
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## SETUP JOOMLA
|
|
function joomla__TRuST__setup() {
|
|
# load this container type globals
|
|
# shellcheck disable=SC1090
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && source "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# we need to pull these values from the env if set
|
|
local vdm_key_db
|
|
local vdm_env_db
|
|
local vdm_key_user
|
|
local vdm_env_user
|
|
local vdm_key_pass
|
|
local vdm_env_pass
|
|
local vdm_key_root
|
|
local vdm_env_root
|
|
# get the Joomla image source
|
|
setImageSource
|
|
# get the key if not set
|
|
setUniqueKey
|
|
# get the env key if not set
|
|
setEnvironmentKey
|
|
# set the domain
|
|
setDomain
|
|
# get the sub domain if not set TODO get dynamic joomla domain name
|
|
setSubDomain "${VDM_KEY,,}" "joomla"
|
|
# check if we have secure switch set
|
|
setSecureState
|
|
# setup letsencrypt stuff
|
|
VDM_JOOMLA_SECURE_LABELS=''
|
|
VDM_PHPMYADMIN_SECURE_LABELS=''
|
|
if $VDM_SECURE; then
|
|
VDM_REMOVE_SECURE=''
|
|
VDM_ENTRY_POINT="websecure"
|
|
VDM_HTTP_SCHEME="https://"
|
|
setSecureCloudflareState
|
|
# add joomla labels
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.entrypoints=web\"")
|
|
else
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.service=joomla${VDM_KEY}\"")
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.services.joomla${VDM_KEY}.loadbalancer.server.port=80\"")
|
|
# add phpmyadmin labels
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.entrypoints=web\"")
|
|
else
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.service=phpmyadmin${VDM_KEY}\"")
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.services.phpmyadmin${VDM_KEY}.loadbalancer.server.port=80\"")
|
|
else
|
|
VDM_REMOVE_SECURE="#"
|
|
VDM_ENTRY_POINT="web"
|
|
VDM_HTTP_SCHEME="http://"
|
|
fi
|
|
# set the details
|
|
vdm_key_db="VDM_${VDM_ENV_KEY^^}_DB"
|
|
vdm_env_db="${!vdm_key_db}"
|
|
vdm_key_user="VDM_${VDM_ENV_KEY^^}_DB_USER"
|
|
vdm_env_user="${!vdm_key_user}"
|
|
vdm_key_pass="VDM_${VDM_ENV_KEY^^}_DB_PASS"
|
|
vdm_env_pass="${!vdm_key_pass}"
|
|
vdm_key_root="VDM_${VDM_ENV_KEY^^}_DB_ROOT"
|
|
vdm_env_root="${!vdm_key_root}"
|
|
# now we check if its has been set
|
|
vdm_database_name="${vdm_database_name:-$vdm_env_db}"
|
|
vdm_database_user="${vdm_database_user:-$vdm_env_user}"
|
|
vdm_database_pass="${vdm_database_pass:-$vdm_env_pass}"
|
|
vdm_database_rootpass="${vdm_database_rootpass:-$vdm_env_root}"
|
|
# check if env is already set
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && grep -q "VDM_${VDM_ENV_KEY^^}_DB=" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" || {
|
|
# add a space or create the file
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && echo '' >>"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# get the database name needed
|
|
while [ ${#vdm_database_name} -le 1 ]; do
|
|
# get the value
|
|
vdm_database_name=$(getInput "Enter Database Name\n[Text with no spaces that is only underscore and alphabetical]" \
|
|
"vdm_io" 'Enter Database Name')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_database_name} -ge 1 ] || {
|
|
showError "You must enter a database name!"
|
|
}
|
|
done
|
|
# get the database user name needed
|
|
while [ ${#vdm_database_user} -le 1 ]; do
|
|
# get the value
|
|
vdm_database_user=$(getInput "Enter Database Username\n[Text with no spaces that is only underscore and alphabetical]" \
|
|
"vdm_user" 'Enter Database Username')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_database_user} -ge 1 ] || {
|
|
showError "You must enter a database username!"
|
|
}
|
|
done
|
|
# get the database user password needed
|
|
while [ ${#vdm_database_pass} -le 1 ]; do
|
|
# get the value
|
|
vdm_database_pass=$(getPassword "Enter Database User Password" \
|
|
"$(getRandomPass 20)" 'Enter Database User Password')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_database_pass} -ge 1 ] || {
|
|
showError "You must enter a database user password!"
|
|
}
|
|
done
|
|
# get the database root password
|
|
while [ ${#vdm_database_rootpass} -le 1 ]; do
|
|
# get the value
|
|
vdm_database_rootpass=$(getPassword "Enter Database Root Password" \
|
|
"$(getRandomPass 40)" 'Enter Database Root Password')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_database_rootpass} -ge 1 ] || {
|
|
showError "You must enter a database root password!"
|
|
}
|
|
done
|
|
}
|
|
# set persistence
|
|
VDM_JOOMLA_VOLUMES_MOUNT=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_KEY}/joomla:/var/www/html\"")
|
|
VDM_DB_VOLUMES_MOUNT=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_KEY}/db:/var/lib/mysql\"")
|
|
VDM_EXTRA_CONTAINER_STUFF=''
|
|
VDM_EXTRA_JOOMLA_ENV=''
|
|
VDM_VOLUMES='volumes:'
|
|
reset_volume=true
|
|
# only if in expert mode
|
|
if isExpert && ! setPersistence 'Joomla website files and folders'; then
|
|
VDM_JOOMLA_VOLUMES_MOUNT=$(getYMLine3 "- ${VDM_KEY,,}_web:/var/www/html")
|
|
VDM_VOLUMES+=$(getYMLine1 "${VDM_KEY,,}_web:")
|
|
reset_volume=false
|
|
fi
|
|
# only if in expert mode
|
|
if isExpert && ! setPersistence 'Joomla database'; then
|
|
VDM_DB_VOLUMES_MOUNT=$(getYMLine3 "- ${VDM_KEY,,}_db:/var/lib/mysql")
|
|
VDM_VOLUMES+=$(getYMLine1 "${VDM_KEY,,}_db:")
|
|
reset_volume=false
|
|
fi
|
|
# check if we have to reset the volume value
|
|
$reset_volume && VDM_VOLUMES=''
|
|
# add the projects path
|
|
setContainerEnvVariable "VDM_PROJECT_PATH=\"${VDM_PROJECT_PATH}\""
|
|
# ask if we should add mailcatcher
|
|
if (whiptail --yesno "Would you also like to enable mailcatcher for these ${VDM_CONTAINER_TYPE^} containers" \
|
|
--defaultno --title "Enable Mailcatcher" --backtitle "${BACK_TITLE}" 8 112); then
|
|
VDM_EXTRA_CONTAINER_STUFF=$(getYMLine1 "mailcatcher${VDM_KEY}:")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "image: schickling/mailcatcher")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "container_name: mailcatcher${VDM_KEY}")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "restart: unless-stopped")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "networks:")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- traefik")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "labels:")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "# mailcatcher")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.enable=true\"")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.rule=Host(\`${VDM_SUBDOMAIN}mail.${VDM_DOMAIN}\`)\"")
|
|
if $VDM_SECURE; then
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.entrypoints=web\"")
|
|
else
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
fi
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.service=mailcatcher${VDM_KEY}\"")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.services.mailcatcher${VDM_KEY}.loadbalancer.server.port=1080\"")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_SMTP_HOST=mailcatcher${VDM_KEY}")
|
|
fi
|
|
# only if in expert mode set the container user detail id needed
|
|
if isExpert; then
|
|
# if this is our octoleo images we can also set the user ID and user-group ID
|
|
setContainerUser "$(id -u)"
|
|
# check that we got the details
|
|
if [ -n "${VDM_PUID}" ] && [ -n "${VDM_PGID}" ]; then
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_PUID=\"#${VDM_PUID}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_PGID=\"#${VDM_PGID}\""
|
|
fi
|
|
fi
|
|
# add this value if not set variable
|
|
[ ${#vdm_database_name} -ge 1 ] && setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB=\"${vdm_database_name}\""
|
|
# add this value if not set variable
|
|
[ ${#vdm_database_user} -ge 1 ] && setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB_USER=\"${vdm_database_user}\""
|
|
# add this value if not set variable
|
|
[ ${#vdm_database_pass} -ge 1 ] && setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB_PASS=\"${vdm_database_pass}\""
|
|
# add this value if not set variable
|
|
[ ${#vdm_database_rootpass} -ge 1 ] && setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB_ROOT=\"${vdm_database_rootpass}\""
|
|
# we only do autodeploy for Joomla 4.3 and above
|
|
if isVersionAbove "$VDM_JV" "4.3"; then
|
|
# setup the website auto deploy details
|
|
setJoomlaWebsiteDetails
|
|
if [[ -n "${VDM_J_EMAIL}" ]]; then
|
|
# add extra Joomla envs
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_TYPE=\"mysqli\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_PREFIX=\"${VDM_KEY}_\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_SITE_NAME=\"${VDM_J_SITE_NAME}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USERNAME=\"${VDM_J_USERNAME}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USER=\"${VDM_J_USER}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_EMAIL=\"${VDM_J_EMAIL}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_PASSWORD=\"${VDM_J_PASSWORD}\""
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_DB_TYPE=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_TYPE}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_DB_PREFIX=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_PREFIX}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_SITE_NAME=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_SITE_NAME}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_USERNAME=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USERNAME}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_USER=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USER}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_EMAIL=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_EMAIL}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_PASSWORD=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_PASSWORD}")
|
|
fi
|
|
fi
|
|
# add PHP settings
|
|
VDM_PHP_PROJECT_PATH="${VDM_KEY}"
|
|
export VDM_PHP_PROJECT_PATH
|
|
if isExpert && setPHPSettings; then
|
|
VDM_JOOMLA_VOLUMES_MOUNT+=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini:/var/www/html/php.ini\"")
|
|
fi
|
|
# customize docker-entrypoint.sh
|
|
VDM_ENTRY_PROJECT_PATH="${VDM_KEY}"
|
|
export VDM_ENTRY_PROJECT_PATH
|
|
if isExpert && setDockerEntrypoint; then
|
|
VDM_JOOMLA_VOLUMES_MOUNT+=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}/entrypoint.sh:/entrypoint.sh\"")
|
|
fi
|
|
##########################
|
|
### export all we need
|
|
# global
|
|
export VDM_CONTAINER_TYPE
|
|
export VDM_REPO_PATH
|
|
export VDM_PROJECT_PATH
|
|
# container
|
|
export VDM_REMOVE_SECURE
|
|
export VDM_ENTRY_POINT
|
|
export VDM_HTTP_SCHEME
|
|
export VDM_PERSISTENCE
|
|
export VDM_NOT_PERSISTENCE
|
|
export VDM_VOLUMES
|
|
export VDM_JOOMLA_VOLUMES_MOUNT
|
|
export VDM_DB_VOLUMES_MOUNT
|
|
export VDM_EXTRA_CONTAINER_STUFF
|
|
export VDM_JOOMLA_SECURE_LABELS
|
|
export VDM_PHPMYADMIN_SECURE_LABELS
|
|
export VDM_EXTRA_JOOMLA_ENV
|
|
# container lower
|
|
export vdm_database_name
|
|
export vdm_database_user
|
|
export vdm_database_pass
|
|
export vdm_database_rootpass
|
|
# set host file if needed
|
|
updateHostFile
|
|
# also set the database domain
|
|
updateHostFile "${VDM_SUBDOMAIN}db"
|
|
# create the directory if it does not yet already exist
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}"
|
|
# place this docker composer file in its place
|
|
joomlaContainer >"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}/docker-compose.yml"
|
|
# set permissions
|
|
chmod 600 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}/docker-compose.yml"
|
|
# saved the file
|
|
showNotice "Saved ${VDM_CONTAINER_TYPE}:docker-compose.yml file.\nSetup of this container is complete!"
|
|
# ask if we should continue to enable
|
|
if (whiptail --yesno "Would you also like to enable this ${VDM_CONTAINER_TYPE^} container" \
|
|
--defaultno --title "Enable Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the container details
|
|
export VDM_CONTAINER="${VDM_SUBDOMAIN}.${VDM_DOMAIN}"
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
# display the configurations
|
|
showJoomlaConfigDetails
|
|
##########################
|
|
### unset all no longer needed
|
|
# container
|
|
unset VDM_SUBDOMAIN
|
|
unset VDM_J_REPO
|
|
unset VDM_ENTRY_REPO
|
|
unset VDM_JV
|
|
unset VDM_KEY
|
|
unset VDM_ENV_KEY
|
|
unset VDM_REMOVE_SECURE
|
|
unset VDM_ENTRY_POINT
|
|
unset VDM_HTTP_SCHEME
|
|
unset VDM_PERSISTENCE
|
|
unset VDM_NOT_PERSISTENCE
|
|
unset VDM_VOLUMES
|
|
unset VDM_JOOMLA_VOLUMES_MOUNT
|
|
unset VDM_DB_VOLUMES_MOUNT
|
|
unset VDM_PHP_PROJECT_PATH
|
|
unset VDM_ENTRY_PROJECT_PATH
|
|
unset VDM_EXTRA_CONTAINER_STUFF
|
|
unset VDM_JOOMLA_SECURE_LABELS
|
|
unset VDM_PHPMYADMIN_SECURE_LABELS
|
|
unset VDM_EXTRA_JOOMLA_ENV
|
|
unset VDM_J_SITE_NAME
|
|
unset VDM_J_USERNAME
|
|
unset VDM_J_USER
|
|
unset VDM_J_EMAIL
|
|
unset VDM_J_PASSWORD
|
|
# container lower
|
|
unset vdm_database_name
|
|
unset vdm_database_user
|
|
unset vdm_database_pass
|
|
unset vdm_database_rootpass
|
|
# return a success
|
|
return 0
|
|
}
|
|
|
|
# return the Joomla Container setup yml
|
|
function joomlaContainer() {
|
|
# set the USER if set
|
|
vdm_container_user=''
|
|
if [ -n "${VDM_PUID}" ] && [ -n "${VDM_PGID}" ]; then
|
|
vdm_container_user="
|
|
- APACHE_RUN_USER=\${VDM_${VDM_ENV_KEY^^}_PUID}
|
|
- APACHE_RUN_GROUP=\${VDM_${VDM_ENV_KEY^^}_PGID}"
|
|
fi
|
|
# we build the yml file
|
|
cat <<EOF
|
|
version: '2'
|
|
services:
|
|
mariadb${VDM_KEY}:
|
|
image: mariadb:latest
|
|
container_name: mariadb${VDM_KEY}
|
|
restart: unless-stopped
|
|
environment:
|
|
- MARIADB_DATABASE=\${VDM_${VDM_ENV_KEY^^}_DB}
|
|
- MARIADB_USER=\${VDM_${VDM_ENV_KEY^^}_DB_USER}
|
|
- MARIADB_PASSWORD=\${VDM_${VDM_ENV_KEY^^}_DB_PASS}
|
|
- MARIADB_ROOT_PASSWORD=\${VDM_${VDM_ENV_KEY^^}_DB_ROOT}
|
|
volumes:${VDM_DB_VOLUMES_MOUNT}
|
|
networks:
|
|
- traefik
|
|
joomla${VDM_KEY}:
|
|
image: ${VDM_J_REPO}:${VDM_JV}
|
|
container_name: joomla${VDM_KEY}
|
|
restart: unless-stopped
|
|
environment:${vdm_container_user}
|
|
- JOOMLA_DB_HOST=mariadb${VDM_KEY}:3306
|
|
- JOOMLA_DB_NAME=\${VDM_${VDM_ENV_KEY^^}_DB}
|
|
- JOOMLA_DB_USER=\${VDM_${VDM_ENV_KEY^^}_DB_USER}
|
|
- JOOMLA_DB_PASSWORD=\${VDM_${VDM_ENV_KEY^^}_DB_PASS}${VDM_EXTRA_JOOMLA_ENV}
|
|
depends_on:
|
|
- mariadb${VDM_KEY}
|
|
volumes:${VDM_JOOMLA_VOLUMES_MOUNT}
|
|
networks:
|
|
- traefik
|
|
labels:
|
|
# joomla
|
|
- "traefik.enable=true"
|
|
- "traefik.http.routers.joomla${VDM_KEY}.rule=Host(\`${VDM_SUBDOMAIN}.${VDM_DOMAIN}\`)"${VDM_JOOMLA_SECURE_LABELS}
|
|
phpmyadmin${VDM_KEY}:
|
|
image: phpmyadmin/phpmyadmin
|
|
container_name: phpmyadmin${VDM_KEY}
|
|
restart: unless-stopped
|
|
environment:
|
|
PMA_HOST: mariadb${VDM_KEY}
|
|
PMA_PORT: 3306
|
|
UPLOAD_LIMIT: 300M
|
|
depends_on:
|
|
- mariadb${VDM_KEY}
|
|
networks:
|
|
- traefik
|
|
labels:
|
|
# phpmyadmin
|
|
- "traefik.enable=true"
|
|
- "traefik.http.routers.phpmyadmin${VDM_KEY}.rule=Host(\`${VDM_SUBDOMAIN}db.${VDM_DOMAIN}\`)"${VDM_PHPMYADMIN_SECURE_LABELS}${VDM_EXTRA_CONTAINER_STUFF}
|
|
networks:
|
|
traefik:
|
|
external: true
|
|
name: ${VDM_TRAEFIK_GATEWAY:-traefik_webgateway}
|
|
|
|
${VDM_VOLUMES}
|
|
|
|
EOF
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## BULK SETUP JOOMLA
|
|
function joomla__TRuST__bulk() {
|
|
# load this container type globals
|
|
# shellcheck disable=SC1090
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && source "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# we need to pull these values from the env if set
|
|
local vdm_key
|
|
local vdm_subdomain
|
|
local vdm_database_name
|
|
local vdm_bulk_database_name
|
|
local vdm_database_user
|
|
local vdm_bulk_database_user
|
|
local vdm_database_pass
|
|
local vdm_bulk_database_user
|
|
local vdm_database_rootpass
|
|
# get the Joomla image source
|
|
setImageSource
|
|
# set the domain
|
|
setDomain
|
|
# get the sub domain if not set TODO get dynamic joomla domain name
|
|
setSubDomain "subdomain" "joomla"
|
|
vdm_subdomain="${VDM_SUBDOMAIN}"
|
|
# check if we have secure switch set
|
|
setSecureState
|
|
# setup letsencrypt stuff
|
|
if $VDM_SECURE; then
|
|
VDM_REMOVE_SECURE=''
|
|
VDM_ENTRY_POINT="websecure"
|
|
VDM_HTTP_SCHEME="https://"
|
|
setSecureCloudflareState
|
|
else
|
|
VDM_REMOVE_SECURE="#"
|
|
VDM_ENTRY_POINT="web"
|
|
VDM_HTTP_SCHEME="http://"
|
|
fi
|
|
# get the database name needed
|
|
while [ ${#vdm_bulk_database_name} -le 1 ]; do
|
|
# get the value
|
|
vdm_bulk_database_name=$(getInput "Enter Database Name\n[Text with no spaces that is only underscore and alphabetical]" \
|
|
"vdm_io" 'Enter Database Name')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_bulk_database_name} -ge 1 ] || {
|
|
showError "You must enter a database name!"
|
|
}
|
|
done
|
|
# get the database user name needed
|
|
while [ ${#vdm_bulk_database_user} -le 1 ]; do
|
|
# get the value
|
|
vdm_bulk_database_user=$(getInput "Enter Database Username\n[Text with no spaces that is only underscore and alphabetical]" \
|
|
"vdm_user" 'Enter Database Username')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_bulk_database_user} -ge 1 ] || {
|
|
showError "You must enter a database username!"
|
|
}
|
|
done
|
|
# get the database user password needed
|
|
while [ ${#vdm_bulk_database_pass} -le 1 ]; do
|
|
# get the value
|
|
vdm_bulk_database_pass=$(getPassword "Enter Database User Password" \
|
|
"$(getRandomPass 20)" 'Enter Database User Password')
|
|
# keep asking if empty or does exist
|
|
[ ${#vdm_bulk_database_pass} -ge 1 ] || {
|
|
showError "You must enter a database user password!"
|
|
}
|
|
done
|
|
# only if in expert mode set the container user detail id needed
|
|
if isExpert; then
|
|
# if this is our octoleo images we can also set the user ID and user-group ID
|
|
setContainerUser "$(id -u)"
|
|
fi
|
|
# add PHP settings
|
|
set_php_settings=false
|
|
VDM_PHP_PROJECT_PATH="bulk"
|
|
export VDM_PHP_PROJECT_PATH
|
|
if isExpert && setPHPSettings; then
|
|
set_php_settings=true
|
|
fi
|
|
# customize docker-entrypoint.sh
|
|
set_docker_entry_point=false
|
|
VDM_ENTRY_PROJECT_PATH="bulk"
|
|
export VDM_ENTRY_PROJECT_PATH
|
|
if isExpert && setDockerEntrypoint; then
|
|
set_docker_entry_point=true
|
|
fi
|
|
# set persistence
|
|
persistence_volume=false
|
|
persistence_db=false
|
|
# only if in expert mode
|
|
if isExpert && setPersistence 'Joomla website files and folders'; then
|
|
persistence_volume=true
|
|
fi
|
|
# only if in expert mode
|
|
if isExpert && setPersistence 'Joomla database'; then
|
|
persistence_db=true
|
|
fi
|
|
# ask if we should add mailcatcher
|
|
enable_mailcatcher=false
|
|
if (whiptail --yesno "Would you also like to enable mailcatcher for these ${VDM_CONTAINER_TYPE^} containers" \
|
|
--defaultno --title "Enable Mailcatcher" --backtitle "${BACK_TITLE}" 8 112); then
|
|
enable_mailcatcher=true
|
|
fi
|
|
# we only do autodeploy for Joomla 4.3 and above
|
|
enable_autodeploy=false
|
|
if isVersionAbove "$VDM_JV" "4.3"; then
|
|
# get website setup details
|
|
setJoomlaWebsiteDetails
|
|
if [[ -n "${VDM_J_EMAIL}" ]]; then
|
|
enable_autodeploy=true
|
|
fi
|
|
fi
|
|
# add the projects path
|
|
setContainerEnvVariable "VDM_PROJECT_PATH=\"${VDM_PROJECT_PATH}\""
|
|
##########################
|
|
### export all we need
|
|
# global
|
|
export VDM_CONTAINER_TYPE
|
|
export VDM_REPO_PATH
|
|
export VDM_PROJECT_PATH
|
|
# container
|
|
export VDM_REMOVE_SECURE
|
|
export VDM_ENTRY_POINT
|
|
export VDM_HTTP_SCHEME
|
|
export VDM_PERSISTENCE
|
|
export VDM_NOT_PERSISTENCE
|
|
# get the number of containers
|
|
setNumberContainers
|
|
# ask if we should continue to enable
|
|
enable_containers=false
|
|
if (whiptail --yesno "Would you also like to enable all these ${VDM_CONTAINER_TYPE^} containers" \
|
|
--defaultno --title "Enable Containers" --backtitle "${BACK_TITLE}" 8 112); then
|
|
enable_containers=true
|
|
fi
|
|
# loop the number of containers
|
|
for (( i=1; i<=VDM_NUMBER_CONTAINERS; i++ ))
|
|
do
|
|
vdm_key=$(getRandomName 5)
|
|
VDM_KEY="${vdm_key,,}"
|
|
VDM_ENV_KEY="${vdm_key^^}"
|
|
VDM_SUBDOMAIN="${vdm_subdomain}${i}"
|
|
vdm_database_name="${vdm_bulk_database_name}${i}"
|
|
vdm_database_user="${vdm_bulk_database_user}${i}"
|
|
vdm_database_pass="${vdm_bulk_database_pass}${i}"
|
|
vdm_database_rootpass=$(getRandomPass 30)
|
|
# reset some globals
|
|
VDM_EXTRA_CONTAINER_STUFF=''
|
|
VDM_EXTRA_JOOMLA_ENV=''
|
|
# check that we got the details
|
|
if [ -n "${VDM_PUID}" ] && [ -n "${VDM_PGID}" ]; then
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_PUID=\"#${VDM_PUID}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_PGID=\"#${VDM_PGID}\""
|
|
fi
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB=\"${vdm_database_name}\""
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB_USER=\"${vdm_database_user}\""
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB_PASS=\"${vdm_database_pass}\""
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_DB_ROOT=\"${vdm_database_rootpass}\""
|
|
# we only do autodeploy for Joomla 4.3 and above
|
|
if $enable_autodeploy; then
|
|
# add extra Joomla envs
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_TYPE=\"mysqli\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_PREFIX=\"${VDM_KEY}_\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_SITE_NAME=\"${VDM_J_SITE_NAME} ${i}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USERNAME=\"${VDM_J_USERNAME}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USER=\"${VDM_J_USER}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_EMAIL=\"${VDM_J_EMAIL}\""
|
|
setContainerEnvVariable "VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_PASSWORD=\"${VDM_J_PASSWORD}\""
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_DB_TYPE=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_TYPE}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_DB_PREFIX=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_DB_PREFIX}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_SITE_NAME=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_SITE_NAME}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_USERNAME=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USERNAME}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_USER=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_USER}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_EMAIL=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_EMAIL}")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_ADMIN_PASSWORD=\${VDM_${VDM_ENV_KEY^^}_JOOMLA_ADMIN_PASSWORD}")
|
|
fi
|
|
# set persistence
|
|
reset_volume=true
|
|
VDM_JOOMLA_VOLUMES_MOUNT=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_KEY}/joomla:/var/www/html\"")
|
|
VDM_DB_VOLUMES_MOUNT=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_KEY}/db:/var/lib/mysql\"")
|
|
VDM_VOLUMES='volumes:'
|
|
if ! $persistence_volume; then
|
|
VDM_JOOMLA_VOLUMES_MOUNT=$(getYMLine3 "- ${VDM_KEY,,}_web:/var/www/html")
|
|
VDM_VOLUMES+=$(getYMLine1 "${VDM_KEY,,}_web:")
|
|
reset_volume=false
|
|
fi
|
|
if ! $persistence_db; then
|
|
VDM_DB_VOLUMES_MOUNT=$(getYMLine3 "- ${VDM_KEY,,}_db:/var/lib/mysql")
|
|
VDM_VOLUMES+=$(getYMLine1 "${VDM_KEY,,}_db:")
|
|
reset_volume=false
|
|
fi
|
|
# add PHP settings
|
|
if $set_php_settings; then
|
|
VDM_JOOMLA_VOLUMES_MOUNT+=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini:/var/www/html/php.ini\"")
|
|
fi
|
|
# customize docker-entrypoint.sh
|
|
if $set_docker_entry_point; then
|
|
VDM_JOOMLA_VOLUMES_MOUNT+=$(getYMLine3 "- \"\${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}/entrypoint.sh:/entrypoint.sh\"")
|
|
fi
|
|
# check if we have to reset the volume value
|
|
$reset_volume && VDM_VOLUMES=''
|
|
# add the mailcatcher if needed
|
|
if $enable_mailcatcher; then
|
|
VDM_EXTRA_CONTAINER_STUFF=$(getYMLine1 "mailcatcher${VDM_KEY}:")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "image: schickling/mailcatcher")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "container_name: mailcatcher${VDM_KEY}")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "restart: unless-stopped")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "networks:")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- traefik")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine2 "labels:")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "# mailcatcher")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.enable=true\"")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.rule=Host(\`${VDM_SUBDOMAIN}mail.${VDM_DOMAIN}\`)\"")
|
|
if $VDM_SECURE; then
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.entrypoints=web\"")
|
|
else
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
fi
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.routers.mailcatcher${VDM_KEY}.service=mailcatcher${VDM_KEY}\"")
|
|
VDM_EXTRA_CONTAINER_STUFF+=$(getYMLine3 "- \"traefik.http.services.mailcatcher${VDM_KEY}.loadbalancer.server.port=1080\"")
|
|
VDM_EXTRA_JOOMLA_ENV+=$(getYMLine3 "- JOOMLA_SMTP_HOST=mailcatcher${VDM_KEY}")
|
|
fi
|
|
# setup letsencrypt stuff
|
|
VDM_JOOMLA_SECURE_LABELS=''
|
|
VDM_PHPMYADMIN_SECURE_LABELS=''
|
|
if $VDM_SECURE; then
|
|
# add joomla labels
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.entrypoints=web\"")
|
|
else
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.joomla${VDM_KEY}.service=joomla${VDM_KEY}\"")
|
|
VDM_JOOMLA_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.services.joomla${VDM_KEY}.loadbalancer.server.port=80\"")
|
|
# add phpmyadmin labels
|
|
if $VDM_SECURE_CLOUDFLARE; then
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.entrypoints=web\"")
|
|
else
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.entrypoints=${VDM_ENTRY_POINT}\"")
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.tls.certresolver=vdmresolver\"")
|
|
fi
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.routers.phpmyadmin${VDM_KEY}.service=phpmyadmin${VDM_KEY}\"")
|
|
VDM_PHPMYADMIN_SECURE_LABELS+=$(getYMLine3 "- \"traefik.http.services.phpmyadmin${VDM_KEY}.loadbalancer.server.port=80\"")
|
|
fi
|
|
# global
|
|
export VDM_KEY
|
|
export VDM_ENV_KEY
|
|
export VDM_SUBDOMAIN
|
|
# container
|
|
export VDM_VOLUMES
|
|
export VDM_JOOMLA_VOLUMES_MOUNT
|
|
export VDM_DB_VOLUMES_MOUNT
|
|
export VDM_EXTRA_CONTAINER_STUFF
|
|
export VDM_JOOMLA_SECURE_LABELS
|
|
export VDM_PHPMYADMIN_SECURE_LABELS
|
|
export VDM_EXTRA_JOOMLA_ENV
|
|
# container lower
|
|
export vdm_database_name
|
|
export vdm_database_user
|
|
export vdm_database_pass
|
|
export vdm_database_rootpass
|
|
# create the directory if it does not yet already exist
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}"
|
|
# place this docker composer file in its place
|
|
joomlaContainer >"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}/docker-compose.yml"
|
|
# set permissions
|
|
chmod 600 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}/docker-compose.yml"
|
|
# enable the container
|
|
if $enable_containers; then
|
|
# we set the container details
|
|
export VDM_CONTAINER="${VDM_SUBDOMAIN}.${VDM_DOMAIN}"
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
done
|
|
##########################
|
|
### unset all no longer needed
|
|
# container
|
|
unset VDM_SUBDOMAIN
|
|
unset VDM_J_REPO
|
|
unset VDM_ENTRY_REPO
|
|
unset VDM_JV
|
|
unset VDM_KEY
|
|
unset VDM_ENV_KEY
|
|
unset VDM_REMOVE_SECURE
|
|
unset VDM_ENTRY_POINT
|
|
unset VDM_HTTP_SCHEME
|
|
unset VDM_PERSISTENCE
|
|
unset VDM_NOT_PERSISTENCE
|
|
unset VDM_VOLUMES
|
|
unset VDM_JOOMLA_VOLUMES_MOUNT
|
|
unset VDM_DB_VOLUMES_MOUNT
|
|
unset VDM_NUMBER_CONTAINERS
|
|
unset VDM_PHP_PROJECT_PATH
|
|
unset VDM_ENTRY_PROJECT_PATH
|
|
unset VDM_EXTRA_CONTAINER_STUFF
|
|
unset VDM_JOOMLA_SECURE_LABELS
|
|
unset VDM_PHPMYADMIN_SECURE_LABELS
|
|
unset VDM_J_SITE_NAME
|
|
unset VDM_J_USERNAME
|
|
unset VDM_J_USER
|
|
unset VDM_J_EMAIL
|
|
unset VDM_J_PASSWORD
|
|
# container lower
|
|
unset vdm_database_name
|
|
unset vdm_database_user
|
|
unset vdm_database_pass
|
|
unset vdm_database_rootpass
|
|
# return a success
|
|
return 0
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## SETUP OPENSSH
|
|
function openssh__TRuST__setup() {
|
|
# load this container type globals
|
|
# shellcheck disable=SC1090
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && source "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# get the ssh port if not set
|
|
while [ ${#VDM_PORT} -le 1 ]; do
|
|
# get the value
|
|
VDM_PORT=$(getInput 'Enter ssh port to use\n[do not use 22]' '' 'Enter Port')
|
|
# keep asking
|
|
[ ${#VDM_PORT} -ge 1 ] || {
|
|
showError "You must enter a ssh port for the container"
|
|
}
|
|
done
|
|
# set the main domain if not set
|
|
setMainDomain
|
|
# get the username if not set
|
|
while [ ${#VDM_USER_NAME} -le 1 ] || [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_USER_NAME}.${VDM_DOMAIN}" ]; do
|
|
# get the value
|
|
VDM_USER_NAME=$(getInput 'Enter username of the container\n[Text with no spaces that is only alphabetical]' 'ubuntu' 'Enter Username')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_USER_NAME} -ge 1 ] && [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_USER_NAME}.${VDM_DOMAIN}" ]; then
|
|
showError "The username:${VDM_USER_NAME} is already used. Select another"
|
|
elif [ ${#VDM_USER_NAME} -le 1 ]; then
|
|
showError "You must enter a username for the container"
|
|
fi
|
|
done
|
|
# be sure to set the container USER ID
|
|
setContainerUser 33
|
|
# get the key if not set
|
|
setUniqueKey "Enter key used for container naming."
|
|
# get the env key if not set
|
|
setEnvironmentKey
|
|
# we check if it was set
|
|
[ ${#VDM_PUBLIC_KEY_GLOBAL_DIR} -le 1 ] && VDM_PUBLIC_KEY_GLOBAL_DIR="${VDM_PUBLIC_KEY_DIR:-}"
|
|
# get the global directory of the ssh public keys if not set
|
|
while [ ${#VDM_PUBLIC_KEY_GLOBAL_DIR} -le 1 ] || [ ! -d "${VDM_PUBLIC_KEY_GLOBAL_DIR}" ]; do
|
|
# creat the path if it exist
|
|
if [ ${#VDM_PUBLIC_KEY_GLOBAL_DIR} -ge 1 ] &&
|
|
(whiptail --yesno "Can we create the ${VDM_PUBLIC_KEY_GLOBAL_DIR} ssh folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
mkdir -p "${VDM_PUBLIC_KEY_GLOBAL_DIR}"
|
|
else
|
|
# get the value
|
|
VDM_PUBLIC_KEY_GLOBAL_DIR=$(getInput "Enter the ssh path where we can select the ssh key folders from." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.ssh" 'Enter SSH Path')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_PUBLIC_KEY_GLOBAL_DIR} -ge 1 ] && [ ! -d "${VDM_PUBLIC_KEY_GLOBAL_DIR}" ] &&
|
|
(whiptail --yesno "Can we create the ${VDM_PUBLIC_KEY_GLOBAL_DIR} ssh folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_PUBLIC_KEY_GLOBAL_DIR}"
|
|
elif [ ${#VDM_PUBLIC_KEY_GLOBAL_DIR} -le 1 ]; then
|
|
showError "You must set a ssh path where we can select the ssh key folders from."
|
|
fi
|
|
fi
|
|
done
|
|
# set the global key env string for the ssh keys
|
|
VDM_ENV_PUBLIC_KEY_U_DIR="VDM_${VDM_ENV_KEY^^}_PUBLIC_KEY_DIR"
|
|
VDM_PUBLIC_KEY_U_DIR=${!VDM_ENV_PUBLIC_KEY_U_DIR}
|
|
# get the directory of this containers public keys if not set
|
|
while [ ${#VDM_PUBLIC_KEY_U_DIR} -le 1 ] || [ ! -d "${VDM_PUBLIC_KEY_U_DIR}" ]; do
|
|
# creat the path if it exist
|
|
if [ ${#VDM_PUBLIC_KEY_U_DIR} -ge 1 ] &&
|
|
(whiptail --yesno "Can we create this (${VDM_PUBLIC_KEY_U_DIR}) containers' ssh public keys folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_PUBLIC_KEY_U_DIR}"
|
|
else
|
|
# get the value
|
|
VDM_PUBLIC_KEY_U_DIR=$(getSelectedDirectory "Select the containers' ssh public keys folder." \
|
|
"${VDM_PUBLIC_KEY_GLOBAL_DIR}" "${VDM_KEY,,}" 'Select Folder')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_PUBLIC_KEY_U_DIR} -ge 1 ]; then
|
|
# add the parent dir back
|
|
VDM_PUBLIC_KEY_U_DIR="${VDM_PUBLIC_KEY_GLOBAL_DIR}/${VDM_PUBLIC_KEY_U_DIR}"
|
|
# check if this directory exist
|
|
if [ ! -d "${VDM_PUBLIC_KEY_U_DIR}" ] &&
|
|
(whiptail --yesno "Can we create this (${VDM_PUBLIC_KEY_U_DIR}) containers' ssh public keys folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_PUBLIC_KEY_U_DIR}"
|
|
# TODO add option to add keys?
|
|
fi
|
|
else
|
|
showError "You must set a containers' ssh public keys folder."
|
|
fi
|
|
fi
|
|
done
|
|
# we must get the project path
|
|
VDM_ENV_PROJECT_DIR="VDM_${VDM_ENV_KEY^^}_PROJECT_DIR"
|
|
VDM_PROJECT_U_DIR=${!VDM_ENV_PROJECT_DIR}
|
|
# get the directory of the ssh public keys if not set
|
|
while [ ${#VDM_PROJECT_U_DIR} -le 1 ] || [ ! -d "${VDM_PROJECT_U_DIR}" ]; do
|
|
# creat the path if it exist
|
|
if [ ${#VDM_PROJECT_U_DIR} -ge 1 ] &&
|
|
(whiptail --yesno "Can we create the ${VDM_PROJECT_U_DIR} parent mounting directory" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
mkdir -p "${VDM_PROJECT_U_DIR}"
|
|
else
|
|
# get the value
|
|
VDM_PROJECT_U_DIR=$(getInput "Enter the parent path where we can select the folders to mount to this container." \
|
|
"${VDM_PROJECT_PATH}" 'Enter Path')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_PROJECT_U_DIR} -ge 1 ] && [ ! -d "${VDM_PROJECT_U_DIR}" ] &&
|
|
(whiptail --yesno "Can we create the ${VDM_PROJECT_U_DIR} parent mounting directory" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_PROJECT_U_DIR}"
|
|
elif [ ${#VDM_PROJECT_U_DIR} -le 1 ]; then
|
|
showError "You must set a parent mounting directory path where we can select the folders to mount to this container."
|
|
fi
|
|
fi
|
|
done
|
|
# now load the mounting volumes
|
|
while [ ${#VDM_MOUNT_DIRS} -le 1 ]; do
|
|
# get the value
|
|
VDM_MOUNT_DIRS=$(getSelectedDirectories "Select the directories to mount to this container." \
|
|
"${VDM_PROJECT_U_DIR}" 'Select Folders')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_MOUNT_DIRS} -le 1 ]; then
|
|
showError "You must set the directories to mount to this container."
|
|
fi
|
|
done
|
|
# convert the string to an array
|
|
IFS=' ' read -r -a vdm_mount_dirs_array <<<"${VDM_MOUNT_DIRS[@]}"
|
|
# build the mount projects
|
|
VDM_VOLUMES_MOUNT=$(getYMLine3 "- \${${VDM_ENV_PUBLIC_KEY_U_DIR}}:/config/ssh_public_keys")
|
|
# loop over the directories to build the
|
|
for mDir in "${vdm_mount_dirs_array[@]}"; do
|
|
# set the full path
|
|
mDir="${mDir//\"/}"
|
|
# when we mount a joomla volume we may not want to mount the database
|
|
mFull="${VDM_PROJECT_U_DIR}/${mDir}/joomla"
|
|
# add to mount projects
|
|
if [ -d "${mFull}" ] && (whiptail --yesno "Should we ONLY mount the (joomla website files) ${mDir}/joomla directory" \
|
|
--title "Mount Joomla" --backtitle "${BACK_TITLE}" 8 112); then
|
|
VDM_VOLUMES_MOUNT+=$(getYMLine3 "- \${VDM_${VDM_ENV_KEY^^}_PROJECT_DIR}/${mDir}/joomla:/app/${mDir}")
|
|
else
|
|
VDM_VOLUMES_MOUNT+=$(getYMLine3 "- \${VDM_${VDM_ENV_KEY^^}_PROJECT_DIR}/${mDir}:/app/${mDir}")
|
|
fi
|
|
done
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "${VDM_ENV_PROJECT_DIR}=\"${VDM_PROJECT_U_DIR}\""
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "VDM_PUBLIC_KEY_GLOBAL_DIR=\"${VDM_PUBLIC_KEY_GLOBAL_DIR}\""
|
|
# add this value if not set variable
|
|
setContainerEnvVariable "${VDM_ENV_PUBLIC_KEY_U_DIR}=\"${VDM_PUBLIC_KEY_U_DIR}\""
|
|
##########################
|
|
### export all we need
|
|
# global
|
|
export VDM_CONTAINER_TYPE
|
|
export VDM_REPO_PATH
|
|
export VDM_PROJECT_PATH
|
|
# container
|
|
export VDM_PORT
|
|
export VDM_USER_NAME
|
|
export VDM_PUBLIC_KEY_GLOBAL_DIR
|
|
export VDM_PUBLIC_KEY_U_DIR
|
|
export VDM_VOLUMES_MOUNT
|
|
export VDM_PROJECT_U_DIR
|
|
# create the directory if it does not yet already exist
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m 700 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_USER_NAME}.${VDM_DOMAIN}"
|
|
# place this docker composer file in its place
|
|
opensshContainer >"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_USER_NAME}.${VDM_DOMAIN}/docker-compose.yml"
|
|
# set permissions
|
|
chmod 600 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_USER_NAME}.${VDM_DOMAIN}/docker-compose.yml"
|
|
# saved the file
|
|
showNotice "Saved ${VDM_CONTAINER_TYPE}:docker-compose.yml file.\nSetup of this container is complete!"
|
|
# ask if we should continue to enable
|
|
if (whiptail --yesno "Would you also like to enable this ${VDM_CONTAINER_TYPE^} container" \
|
|
--defaultno --title "Enable Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the container details
|
|
export VDM_CONTAINER="${VDM_USER_NAME}.${VDM_DOMAIN}"
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
##########################
|
|
### unset all no longer needed
|
|
# container
|
|
unset VDM_PORT
|
|
unset VDM_USER_NAME
|
|
unset VDM_KEY
|
|
unset VDM_ENV_KEY
|
|
unset VDM_PUBLIC_KEY_GLOBAL_DIR
|
|
unset VDM_PUBLIC_KEY_U_DIR
|
|
unset VDM_VOLUMES_MOUNT
|
|
unset VDM_PROJECT_U_DIR
|
|
# return a success
|
|
return 0
|
|
}
|
|
|
|
# return the Openssh Container setup yml
|
|
function opensshContainer() {
|
|
# we build the yml file
|
|
cat <<EOF
|
|
version: "2.1"
|
|
services:
|
|
openssh-server-${VDM_KEY}:
|
|
image: lscr.io/linuxserver/openssh-server
|
|
container_name: openssh-server-${VDM_KEY}
|
|
restart: unless-stopped
|
|
hostname: ${VDM_DOMAIN:-vdm.dev}
|
|
environment:
|
|
- PUID=${VDM_PUID}
|
|
- PGID=${VDM_PGID}
|
|
- TZ=${VDM_TZ:-Africa/Windhoek}
|
|
- PUBLIC_KEY_DIR=/config/ssh_public_keys
|
|
- SUDO_ACCESS=${VDM_SUDO_ACCESS:-false}
|
|
- USER_NAME=${VDM_USER_NAME:-ubuntu}
|
|
volumes:${VDM_VOLUMES_MOUNT}
|
|
ports:
|
|
- ${VDM_PORT}:2222
|
|
networks:
|
|
- openssh
|
|
|
|
networks:
|
|
openssh:
|
|
name: ${VDM_OPENSSH_GATEWAY:-openssh_gateway}
|
|
EOF
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## EDIT JOOMLA
|
|
function joomla__TRuST__edit() {
|
|
# check if this type have available containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "The path ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/ does not exist or is empty, first run a ${VDM_CONTAINER_TYPE^} setup."
|
|
else
|
|
# set some local variables
|
|
local vdm_edit_me
|
|
local container
|
|
# list containers... and allow selection to edit
|
|
container=$(getSelectedDirectory "Select a container to manually edit the docker-composer.yml file.\n[Only continue if you know what your doing!]" \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" '' "Edit ${VDM_CONTAINER_TYPE^} Container")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#container} -ge 1 ]; then
|
|
# add the parent dir back
|
|
vdm_edit_me="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}/docker-compose.yml"
|
|
# check if this docker-composer.yml exist
|
|
if [ -f "${vdm_edit_me}" ]; then
|
|
# give little heads-up
|
|
showNotice "${USER^}, to save the changes you've made or to just close the file again press:\n\n[ctrl+x] with nano on ubuntu." 13
|
|
# lets open the file with nano for now
|
|
"${EDITOR:-nano}" "${vdm_edit_me}"
|
|
# if this container is enabled ask if it should be redeployed
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}" ] &&
|
|
(whiptail --yesno "Would you like to re-deploy the (${container}) container that you opened to edit?" \
|
|
--title "Re-Deploy Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the container details
|
|
export VDM_CONTAINER="${container}"
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## EDIT OPENSSH
|
|
function openssh__TRuST__edit() {
|
|
# check if this type have available containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "The path ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/ does not exist or is empty, first run a ${VDM_CONTAINER_TYPE^} setup."
|
|
else
|
|
# set some local variables
|
|
local vdm_edit_me
|
|
local container
|
|
# list containers... and allow selection to edit
|
|
container=$(getSelectedDirectory "Select a container to manually edit the docker-composer.yml file.\n[Only continue if you know what your doing!]" \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" '' "Edit ${VDM_CONTAINER_TYPE^} Container")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#container} -ge 1 ]; then
|
|
# add the parent dir back
|
|
vdm_edit_me="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}/docker-compose.yml"
|
|
# check if this docker-composer.yml exist
|
|
if [ -f "${vdm_edit_me}" ]; then
|
|
# give little heads-up
|
|
showNotice "${USER^}, to save the changes you've made or to just close the file again press:\n\n[ctrl+x] with nano on ubuntu." 13
|
|
# lets open the file with nano for now
|
|
"${EDITOR:-nano}" "${vdm_edit_me}"
|
|
# if this container is enabled ask if it should be redeployed
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}" ] &&
|
|
(whiptail --yesno "Would you like to re-deploy the (${container}) container that you opened to edit?" \
|
|
--title "Re-Deploy Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the container details
|
|
export VDM_CONTAINER="${container}"
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## EDIT TRAEFIK
|
|
function traefik__TRuST__edit() {
|
|
# check if traefik has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to edit."
|
|
else
|
|
# give little warning for less command ready people
|
|
if (whiptail --yesno "Only continue if you know what your doing!\n\n\
|
|
${USER^}, to save the changes you've made or to just close the file again press:\n\n\
|
|
[ctrl+x] with nano on ubuntu." --title "Continue to edit ${VDM_CONTAINER_TYPE^} config." \
|
|
--backtitle "${BACK_TITLE}" 15 112); then
|
|
# lets open the file with nano for now
|
|
"${EDITOR:-nano}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
# if this container is enabled ask if it should be redeployed
|
|
if (whiptail --yesno "Would you like to deploy or re-deploy the ${VDM_CONTAINER_TYPE^} container that you opened to edit?" \
|
|
--title "Deploy or Re-Deploy Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## EDIT PORTAINER
|
|
function portainer__TRuST__edit() {
|
|
# check if portainer has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to edit."
|
|
else
|
|
# give little warning for less command ready people
|
|
if (whiptail --yesno "Only continue if you know what your doing!\n\n\
|
|
${USER^}, to save the changes you've made or to just close the file again press:\n\n\
|
|
[ctrl+x] with nano on ubuntu." --title "Continue to edit ${VDM_CONTAINER_TYPE^} config." \
|
|
--backtitle "${BACK_TITLE}" 15 112); then
|
|
# lets open the file with nano for now
|
|
"${EDITOR:-nano}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
# if this container is enabled ask if it should be redeployed
|
|
if (whiptail --yesno "Would you like to deploy or re-deploy the ${VDM_CONTAINER_TYPE^} container that you opened to edit?" \
|
|
--title "Deploy or Re-Deploy Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# then we enable it
|
|
enableContainer "${VDM_CONTAINER_TYPE}"
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## ENABLE JOOMLA
|
|
function joomla__TRuST__enable() {
|
|
# some local values
|
|
local evn_file
|
|
# check if this type have available containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "The path ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/ does not exist or is empty, first run a ${VDM_CONTAINER_TYPE^} setup."
|
|
elif [ ! -d "${VDM_PROJECT_PATH}" ]; then
|
|
# this should never happen, but in case
|
|
showError "The path ${VDM_PROJECT_PATH} does not exist, so we can't mount the persistent volumes. This error should never show, \
|
|
please open an issue and report octojoom-error-1234 with the steps of how you got here?"
|
|
elif [ ${#VDM_CONTAINER} -ge 1 ]; then
|
|
# this means we have a single already selected container to enable if it exists
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_CONTAINER}" ]; then
|
|
# create the folder as needed
|
|
mkdir -p "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"
|
|
# create the soft link
|
|
[ -e "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}" ] || {
|
|
ln -s "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_CONTAINER}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}"
|
|
}
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/.env" || {
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/docker-compose.yml" up -d || {
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/docker-compose.yml" up -d
|
|
}
|
|
else
|
|
showError "The (${VDM_CONTAINER}) container does not exist."
|
|
fi
|
|
# always unset after
|
|
VDM_CONTAINER=''
|
|
unset VDM_CONTAINER
|
|
else
|
|
# set some local variables
|
|
local vdm_enable_me
|
|
local container
|
|
# create the folder as needed
|
|
mkdir -p "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"
|
|
# get containers to enable
|
|
vdm_enable_me=$(getSelectedDirectories "Select container/s to enable." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" "Enable ${VDM_CONTAINER_TYPE^} Containers")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_enable_me} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_enable_me_array <<<"${vdm_enable_me[@]}"
|
|
# loop over the directories to build the
|
|
for containered in "${vdm_enable_me_array[@]}"; do
|
|
# remove the " from the string
|
|
container="${containered//\"/}"
|
|
# create the soft link
|
|
[ -e "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}" ] || {
|
|
ln -s "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}"
|
|
}
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/.env" || {
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" up -d || {
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" up -d
|
|
}
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## ENABLE OPENSSH
|
|
function openssh__TRuST__enable() {
|
|
# check if this type have available containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "The path ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/ does not exist, first run a ${VDM_CONTAINER_TYPE} setup."
|
|
elif [ ${#VDM_CONTAINER} -ge 1 ]; then
|
|
# this means we have a single already selected container to enable if it exists
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_CONTAINER}" ]; then
|
|
# create the folder as needed
|
|
mkdir -p "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"
|
|
# create the soft lin
|
|
[ -e "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}" ] || {
|
|
ln -s "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${VDM_CONTAINER}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}"
|
|
}
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/.env" || {
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/docker-compose.yml" up -d || {
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/docker-compose.yml" up -d
|
|
}
|
|
else
|
|
showError "The (${VDM_CONTAINER}) container does not exist."
|
|
fi
|
|
# always unset after
|
|
VDM_CONTAINER=''
|
|
unset VDM_CONTAINER
|
|
else
|
|
# set some local variables
|
|
local vdm_enable_me
|
|
local container
|
|
local evn_file
|
|
# create the folder as needed
|
|
mkdir -p "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"
|
|
# get containers to enable
|
|
vdm_enable_me=$(getSelectedDirectories "Select container/s to enable." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" "Enable ${VDM_CONTAINER_TYPE^} Containers")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_enable_me} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_enable_me_array <<<"${vdm_enable_me[@]}"
|
|
# loop over the directories to build the
|
|
for containered in "${vdm_enable_me_array[@]}"; do
|
|
# remove the " from the string
|
|
container="${containered//\"/}"
|
|
# create the soft link
|
|
[ -e "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}" ] || {
|
|
ln -s "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}"
|
|
}
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/.env" || {
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" up -d || {
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" up -d
|
|
}
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## ENABLE TRAEFIK
|
|
function traefik__TRuST__enable() {
|
|
# check if traefik has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to enable, first run the ${VDM_CONTAINER_TYPE^} setup."
|
|
else
|
|
# set some local variables
|
|
local evn_file
|
|
# make sure to take down Apache
|
|
downApache
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" || {
|
|
[ -f "${VDM_SRC_PATH}/.env" ] && evn_file="${VDM_SRC_PATH}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" up -d || {
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" up -d
|
|
}
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## ENABLE PORTAINER
|
|
function portainer__TRuST__enable() {
|
|
# check if traefik has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to enable, first run the ${VDM_CONTAINER_TYPE^} setup."
|
|
else
|
|
# set some local variables
|
|
local evn_file
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# shellcheck disable=SC2015
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" || {
|
|
[ -f "${VDM_SRC_PATH}/.env" ] && evn_file="${VDM_SRC_PATH}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" up -d || {
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" up -d
|
|
}
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DISABLE JOOMLA
|
|
function joomla__TRuST__disable() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/enabled/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers to disable."
|
|
elif [ ${#VDM_CONTAINER} -ge 1 ]; then
|
|
# this means we have a single already selected container to enable if it exists
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}" ]; then
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/docker-compose.yml" down --remove-orphans
|
|
# then remove soft link
|
|
rm -rf "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}"
|
|
else
|
|
showError "The (${VDM_CONTAINER}) container is not enabled."
|
|
fi
|
|
# always unset after
|
|
VDM_CONTAINER=''
|
|
unset VDM_CONTAINER
|
|
else
|
|
# set some local variables
|
|
local vdm_disable_me
|
|
local container
|
|
# get containers to enable
|
|
vdm_disable_me=$(getSelectedDirectories "Select container/s to disable." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/" "Disable ${VDM_CONTAINER_TYPE^} Containers")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_disable_me} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_disable_me_array <<<"${vdm_disable_me[@]}"
|
|
# loop over the directories to build the
|
|
for containered in "${vdm_disable_me_array[@]}"; do
|
|
# remove the " from the string
|
|
container="${containered//\"/}"
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" down --remove-orphans
|
|
# then remove soft link
|
|
rm -rf "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}"
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DISABLE OPENSSH
|
|
function openssh__TRuST__disable() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/enabled/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers to disable."
|
|
elif [ ${#VDM_CONTAINER} -ge 1 ]; then
|
|
# this means we have a single already selected container to enable if it exists
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}" ]; then
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}/docker-compose.yml" down --remove-orphans
|
|
# then remove soft link
|
|
rm -rf "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${VDM_CONTAINER}"
|
|
else
|
|
showError "The (${VDM_CONTAINER}) container is not enabled."
|
|
fi
|
|
# always unset after
|
|
VDM_CONTAINER=''
|
|
unset VDM_CONTAINER
|
|
else
|
|
# set some local variables
|
|
local vdm_disable_me
|
|
local container
|
|
# get containers to enable
|
|
vdm_disable_me=$(getSelectedDirectories "Select container/s to disable." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/" "Disable ${VDM_CONTAINER_TYPE^} Containers")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_disable_me} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_disable_me_array <<<"${vdm_disable_me[@]}"
|
|
# loop over the directories to build the
|
|
for containered in "${vdm_disable_me_array[@]}"; do
|
|
# remove the " from the string
|
|
container="${containered//\"/}"
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" down --remove-orphans
|
|
# then remove soft link
|
|
rm -rf "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}"
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DISABLE TRAEFIK
|
|
function traefik__TRuST__disable() {
|
|
# check if traefik has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to disable."
|
|
else
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" down
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DISABLE PORTAINER
|
|
function portainer__TRuST__disable() {
|
|
# check if portainer has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to disable."
|
|
else
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" down
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## UP JOOMLA
|
|
function joomla__TRuST__up() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/enabled/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers enabled, first enable some containers.\n\
|
|
(UP and DOWN targets only enabled containers)"
|
|
else
|
|
# set some local variables
|
|
local evn_file
|
|
local vdm_container
|
|
# get all zip files
|
|
for yml in "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"*/*.yml; do
|
|
# get the vdm_container value
|
|
vdm_container="${yml%/docker-compose.yml}"
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# check if image has its own env file also
|
|
# shellcheck disable=SC2015
|
|
[ -f "${vdm_container}/.env" ] && evn_file="${vdm_container}/.env" || {
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${yml}" up -d || {
|
|
docker-compose --file "${yml}" up -d
|
|
}
|
|
done
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## UP OPENSSH
|
|
function openssh__TRuST__up() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/enabled/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers enabled, first enable some containers.\n\
|
|
(UP and DOWN targets only enabled containers)"
|
|
else
|
|
# set some local variables
|
|
local evn_file
|
|
local vdm_container
|
|
# get all zip files
|
|
for yml in "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"*/*.yml; do
|
|
# get the vdm_container value
|
|
vdm_container="${yml%/docker-compose.yml}"
|
|
# check if image has its own env file also
|
|
evn_file=''
|
|
# check if image has its own env file also
|
|
# shellcheck disable=SC2015
|
|
[ -f "${vdm_container}/.env" ] && evn_file="${vdm_container}/.env" || {
|
|
[ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && evn_file="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
}
|
|
# make sure the docker image is started
|
|
# shellcheck disable=SC2015
|
|
[ ${#evn_file} -ge 1 ] && docker-compose --env-file "${evn_file}" --file "${yml}" up -d || {
|
|
docker-compose --file "${yml}" up -d
|
|
}
|
|
done
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DOWN JOOMLA
|
|
function joomla__TRuST__down() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/enabled/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers to take down.\n\
|
|
(UP and DOWN targets only enabled containers)"
|
|
elif (whiptail --yesno "Are you absolutely sure you want to take down all the ${VDM_CONTAINER_TYPE^} containers?" \
|
|
--title "Take Down Containers" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# get all zip files
|
|
for yml in "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"*/*.yml; do
|
|
docker-compose --file "${yml}" down
|
|
done
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DOWN OPENSSH
|
|
function openssh__TRuST__down() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/enabled/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers to take down."
|
|
elif (whiptail --yesno "Are you absolutely sure you want to take down all the ${VDM_CONTAINER_TYPE^} containers?" \
|
|
--title "Take Down Containers" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# get all zip files
|
|
for yml in "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/"*/*.yml; do
|
|
docker-compose --file "${yml}" down
|
|
done
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DELETE JOOMLA
|
|
function joomla__TRuST__delete() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers available."
|
|
else
|
|
# set some local variables
|
|
local vdm_delete_me
|
|
local container
|
|
# saved the file
|
|
showNotice "Only delete containers of which you have made absolutely sure it's no longer needed! Better to just disable them if all you want is to just take them down."
|
|
# get containers to enable
|
|
vdm_delete_me=$(getSelectedDirectories "Select container/s to delete." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" "Delete ${VDM_CONTAINER_TYPE^} Container/s")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_delete_me} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_delete_me_array <<<"${vdm_delete_me[@]}"
|
|
# loop over the directories to build the
|
|
for containered in "${vdm_delete_me_array[@]}"; do
|
|
# remove the " from the string
|
|
container="${containered//\"/}"
|
|
# check if the container is still enabled
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}" ]; then
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" down
|
|
# then remove soft link
|
|
rm -rf "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}"
|
|
fi
|
|
# before deleting the config we ask to make sure
|
|
if (whiptail --yesno "Would you like to delete the (${container}) container's folder that holds the docker-compose.yml file?" \
|
|
--title "Delete Docker Compose Yaml" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# then remove docker-compose.yml file
|
|
rm -rf "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}"
|
|
fi
|
|
done
|
|
fi
|
|
# ask if there are volumes to delete
|
|
if hasDirectories '' "${VDM_PROJECT_PATH}" &&
|
|
(whiptail --yesno "Would you like to delete persistent volumes found in (${VDM_PROJECT_PATH})?" \
|
|
--title "Continue To Delete Persistent Volumes" --backtitle "${BACK_TITLE}" 12 112); then
|
|
# trigger the volumes removal script
|
|
deletePersistentVolumes
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DELETE OPENSSH
|
|
function openssh__TRuST__delete() {
|
|
# check if this type has enabled containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "There are no ${VDM_CONTAINER_TYPE^} containers available."
|
|
else
|
|
# set some local variables
|
|
local vdm_delete_me
|
|
local container
|
|
# saved the file
|
|
showNotice "Only delete containers of which you have made absolutely sure it's no longer needed! Better to just disable them if all you want is to just take them down."
|
|
# get containers to enable
|
|
vdm_delete_me=$(getSelectedDirectories "Select container/s to delete." \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" "Delete ${VDM_CONTAINER_TYPE^} Container/s")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_delete_me} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_delete_me_array <<<"${vdm_delete_me[@]}"
|
|
# loop over the directories to build the
|
|
for containered in "${vdm_delete_me_array[@]}"; do
|
|
# remove the " from the string
|
|
container="${containered//\"/}"
|
|
# check if the container is still enabled
|
|
if [ -d "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}" ]; then
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}/docker-compose.yml" down
|
|
# then remove soft link
|
|
rm -fr "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/enabled/${container}"
|
|
fi
|
|
# before deleting the config we ask to make sure
|
|
if (whiptail --yesno "Would you like to delete the (${container}) container's folder that holds the docker-compose.yml file?" \
|
|
--title "Delete Docker Compose Yaml" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# then remove docker-compose.yml file
|
|
rm -fr "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}"
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DELETE TRAEFIK
|
|
function traefik__TRuST__delete() {
|
|
# check if traefik has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to delete."
|
|
else
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" down
|
|
# before deleting the config we ask to make sure
|
|
if (whiptail --yesno "Would you like to delete the ${VDM_CONTAINER_TYPE^} container's docker-compose.yml file?" \
|
|
--title "Delete Docker Compose Yaml" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# then remove docker-compose.yml file
|
|
rm -fr "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## DELETE PORTAINER
|
|
function portainer__TRuST__delete() {
|
|
# check if portainer has been setup
|
|
if [ ! -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" ]; then
|
|
showError "There is no ${VDM_CONTAINER_TYPE^} container to delete."
|
|
else
|
|
# make sure the docker image is stopped
|
|
docker-compose --file "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml" down
|
|
# before deleting the config we ask to make sure
|
|
if (whiptail --yesno "Would you like to delete the ${VDM_CONTAINER_TYPE^} container's docker-compose.yml file?" \
|
|
--title "Delete Docker Compose Yaml" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# then remove docker-compose.yml file
|
|
rm -fr "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/docker-compose.yml"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## Migrate Joomla
|
|
function joomla__TRuST__migrate() {
|
|
# check if this type have available containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "The path ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/ does not exist or is empty, first run a ${VDM_CONTAINER_TYPE^} setup."
|
|
else
|
|
# set some local variables
|
|
local type_migration
|
|
local vdm_migrate_me
|
|
local container
|
|
# list containers... and allow selection to edit
|
|
container=$(getSelectedDirectory "Select the container you would like to migrate.\n[Only continue if you know what your doing!] (We will only move docker-composer.yml file)" \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" '' "Migrate ${VDM_CONTAINER_TYPE^} Container")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#container} -ge 1 ]; then
|
|
# add the parent dir back
|
|
vdm_migrate_me="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}/docker-compose.yml"
|
|
# check if this docker-composer.yml exist
|
|
if [ -f "${vdm_migrate_me}" ]; then
|
|
# select the type of migration
|
|
type_migration=$(getMigrationType)
|
|
# get remote system
|
|
remote_system=$(getRemoteSystem)
|
|
# make sure we have a remote
|
|
if [ ${#remote_system} -ge 2 ] && [ "${remote_system}" != "none_selected" ]; then
|
|
# give little heads-up
|
|
if (whiptail --yesno "${USER^}, you selected the container:<${container}> action:<${type_migration}> remote:<${remote_system}>\nIs this correct, and can we continue with the migration ${type_migration}?" \
|
|
--title "Confirm Migration ${type_migration^}" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# run migration
|
|
"${type_migration}ContainerMigration" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}" "${VDM_CONTAINER_TYPE}/available/${container}" "${remote_system}"
|
|
fi
|
|
else
|
|
showError "Migration cancelled since no remote system was selected."
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## Migrate OPENSSH
|
|
function openssh__TRuST__migrate() {
|
|
# check if this type have available containers
|
|
if ! hasDirectories "${VDM_CONTAINER_TYPE}/available/"; then
|
|
showError "The path ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/ does not exist or is empty, first run a ${VDM_CONTAINER_TYPE^} setup."
|
|
else
|
|
# set some local variables
|
|
local vdm_migrate_me
|
|
local container
|
|
# list containers... and allow selection to edit
|
|
container=$(getSelectedDirectory "Select the container you would like to migrate.\n[Only continue if you know what your doing!] (We will only move docker-composer.yml file)" \
|
|
"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/" '' "Migrate ${VDM_CONTAINER_TYPE^} Container")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#container} -ge 1 ]; then
|
|
# add the parent dir back
|
|
vdm_migrate_me="${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}/docker-compose.yml"
|
|
# check if this docker-composer.yml exist
|
|
if [ -f "${vdm_migrate_me}" ]; then
|
|
# select the type of migration
|
|
type_migration=$(getMigrationType)
|
|
# get remote system
|
|
remote_system=$(getRemoteSystem)
|
|
# make sure we have a remote
|
|
if [ ${#remote_system} -ge 2 ] && [ "${remote_system}" != "none_selected" ]; then
|
|
# give little heads-up
|
|
if (whiptail --yesno "${USER^}, you selected the container:<${container}> action:<${type_migration}> remote:<${remote_system}>\nIs this correct, and can we continue with the migration ${type_migration}?" \
|
|
--title "Confirm Migration ${type_migration^}" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# run migration
|
|
"${type_migration}ContainerMigration" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/available/${container}" "${VDM_CONTAINER_TYPE}/available/${container}" "${remote_system}"
|
|
fi
|
|
else
|
|
showError "Migration cancelled since no remote system was selected."
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## Migrate Directory
|
|
function directory__TRuST__migrate() {
|
|
# set some local variables
|
|
local vdm_migrate_me
|
|
local directory
|
|
# Would you also like to move a project folder
|
|
if hasDirectories '' "${VDM_PROJECT_PATH}"; then
|
|
# get project directories to migrate
|
|
directory=$(getSelectedDirectory "Select project directory to migrate.\n[Only continue if you know what your doing!]" \
|
|
"${VDM_PROJECT_PATH}" "Select Project Directory")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#directory} -ge 1 ]; then
|
|
# add the parent dir back
|
|
vdm_migrate_me="${VDM_PROJECT_PATH}/${directory}"
|
|
# check that we have something
|
|
if [ -d "${vdm_migrate_me}" ]; then
|
|
# select the type of migration
|
|
type_migration=$(getMigrationType)
|
|
# get remote system
|
|
remote_system=$(getRemoteSystem)
|
|
# make sure we have a remote
|
|
if [ ${#remote_system} -ge 2 ] && [ "${remote_system}" != "none_selected" ]; then
|
|
# give little heads-up
|
|
if (whiptail --yesno "${USER^}, you selected the directory:<${directory}> action:<${type_migration}> remote:<${remote_system}>\nIs this correct, and can we continue with the migration ${type_migration}?" \
|
|
--title "Confirm Migration ${type_migration^}" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# run migration
|
|
"${type_migration}DirectoryMigration" "${vdm_migrate_me}" "${directory}" "${remote_system}"
|
|
fi
|
|
else
|
|
showError "Migration cancelled since no remote system was selected."
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## MENU ACTIONS
|
|
|
|
# setup a container
|
|
function setupContainer() {
|
|
# make sure the networks are set
|
|
setNetworks
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="setup"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# setup multiple containers
|
|
bulkSetupContainers() {
|
|
# make sure the networks are set
|
|
setNetworks
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="bulk"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# edit a container
|
|
function editContainer() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="edit"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# enable a container
|
|
function enableContainer() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="enable"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# disable a container
|
|
function disableContainer() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="disable"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# down containers
|
|
function downContainers() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="down"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# up containers
|
|
function upContainers() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="up"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# delete a container
|
|
function deleteContainer() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="delete"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# migrate a container
|
|
function migrateContainer() {
|
|
# make sure of our container type
|
|
VDM_CONTAINER_TYPE="${1}"
|
|
VDM_TASK="migrate"
|
|
# execute the task
|
|
main
|
|
}
|
|
|
|
# To fix the permissions of Joomla containers
|
|
function fixContainersPermissions() {
|
|
# check if we have persistent volumes
|
|
if [ ! -d "${VDM_PROJECT_PATH}" ]; then
|
|
showError "The ${VDM_PROJECT_PATH} does not exist."
|
|
elif ! hasDirectories '' "${VDM_PROJECT_PATH}"; then
|
|
showError "There are no persistent volumes in ${VDM_PROJECT_PATH} available."
|
|
else
|
|
# set some local variables
|
|
local vdm_fix_me
|
|
local persistent
|
|
# get containers to enable
|
|
vdm_fix_me=$(getSelectedDirectories "Select persistent volume to fix." \
|
|
"${VDM_PROJECT_PATH}" "Fix Joomla Permissions")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_fix_me} -ge 1 ] && (whiptail --yesno "${USER^}, to fix these permissions we need sudo privileges." \
|
|
--title "Give sudo Privileges" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_fix_me_array <<<"${vdm_fix_me[@]}"
|
|
# just to get sudo pass
|
|
sudo -v
|
|
# loop over the directories to build the
|
|
for volume in "${vdm_fix_me_array[@]}"; do
|
|
# remove the " from the string
|
|
persistent="${volume//\"/}"
|
|
# make sure this is a joomla system
|
|
if [ -d "${VDM_PROJECT_PATH}/${persistent}/joomla" ]; then
|
|
# show the notice of the volume being fixed
|
|
showNotice "Fixing ${persistent}/joomla permissions now."
|
|
# if this is our octoleo images we can also set the user ID and user-group ID
|
|
setContainerUser "$(id -u)"
|
|
### Fix the folder ownership of Joomla folders
|
|
# id -u www-data
|
|
# id -g www-data
|
|
#
|
|
progressSwitchOn
|
|
{
|
|
sudo chown -R "$VDM_PUID":"$VDM_PGID" "${VDM_PROJECT_PATH}/${persistent}/joomla"
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the ownership of ${persistent} Joomla directory/files.\n(chown -R $VDM_PUID:$VDM_PGID ${persistent}/joomla)"
|
|
### Fix the folder permissions for the Joomla websites
|
|
#
|
|
# Change the file permissions
|
|
progressSwitchOn
|
|
{
|
|
sudo find "${VDM_PROJECT_PATH}/${persistent}/joomla" -type f -exec chmod 644 {} \;
|
|
[ -f "${VDM_PROJECT_PATH}/${persistent}/joomla/configuration.php" ] &&
|
|
sudo chmod 444 "${VDM_PROJECT_PATH}/${persistent}/joomla/configuration.php"
|
|
[ -f "${VDM_PROJECT_PATH}/${persistent}/joomla/.htaccess" ] &&
|
|
sudo chmod 400 "${VDM_PROJECT_PATH}/${persistent}/joomla/.htaccess"
|
|
[ -f "${VDM_PROJECT_PATH}/${persistent}/joomla/php.ini" ] &&
|
|
sudo chmod 400 "${VDM_PROJECT_PATH}/${persistent}/joomla/php.ini"
|
|
# at last we are done
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the files permissions for the ${persistent} Joomla website.\n(find ${persistent}/joomla -type f -exec chmod 644 {} \;)"
|
|
# Change the folder permissions
|
|
progressSwitchOn
|
|
{
|
|
sudo find /"home/${USER}/Projects/${persistent}/joomla" -type d -exec chmod 755 {} \;
|
|
# lock jetbrains folder
|
|
[ -e "${VDM_PROJECT_PATH}/${persistent}/joomla/.idea" ] && {
|
|
sudo chmod -R 700 "${VDM_PROJECT_PATH}/${persistent}/joomla/.idea"
|
|
# add a locking .htaccess file and set its access
|
|
lockFolder >"${VDM_PROJECT_PATH}/${persistent}/joomla/.idea/.htaccess"
|
|
sudo chmod 400 "${VDM_PROJECT_PATH}/${persistent}/joomla/.idea/.htaccess"
|
|
}
|
|
# lock hidden folder
|
|
[ -e "${VDM_PROJECT_PATH}/${persistent}/joomla/.hidden" ] && {
|
|
sudo chmod -R 700 "${VDM_PROJECT_PATH}/${persistent}/joomla/.hidden"
|
|
# add a locking .htaccess file and set its access
|
|
lockFolder >"${VDM_PROJECT_PATH}/${persistent}/joomla/.hidden/.htaccess"
|
|
sudo chmod 400 "${VDM_PROJECT_PATH}/${persistent}/joomla/.hidden/.htaccess"
|
|
}
|
|
# lock git folder
|
|
[ -e "${VDM_PROJECT_PATH}/${persistent}/joomla/.git" ] && {
|
|
sudo chmod -R 700 "${VDM_PROJECT_PATH}/${persistent}/joomla/.git"
|
|
# add a locking .htaccess file and set its access
|
|
lockFolder >"${VDM_PROJECT_PATH}/${persistent}/joomla/.git/.htaccess"
|
|
sudo chmod 400 "${VDM_PROJECT_PATH}/${persistent}/joomla/.git/.htaccess"
|
|
}
|
|
# lock the tmp folder
|
|
[ -e "${VDM_PROJECT_PATH}/${persistent}/joomla/tmp" ] && {
|
|
sudo chmod -R 700 "${VDM_PROJECT_PATH}/${persistent}/joomla/tmp"
|
|
# add a locking .htaccess file and set its access
|
|
# lockFolder > "${VDM_PROJECT_PATH}/${persistent}/joomla/tmp/.htaccess"
|
|
# sudo chmod 400 "${VDM_PROJECT_PATH}/${persistent}/joomla/tmp/.htaccess"
|
|
}
|
|
# at last we are done
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the directory permissions for the ${persistent} Joomla website.\n(find ${persistent}/joomla -type d -exec chmod 755 {} \;)"
|
|
# Change the image folder permissions
|
|
# chmod 707 "${VDM_PROJECT_PATH}/${persistent}/joomla/images"
|
|
# chmod 707 "${VDM_PROJECT_PATH}/${persistent}/joomla/images/stories"
|
|
#
|
|
# get current user ID
|
|
user_id="$(id -u)"
|
|
# check if the current user mismatch
|
|
if [ "$user_id" != "$VDM_PUID" ]; then
|
|
# Check if the setfacl command is installed
|
|
# shellcheck disable=SC2015
|
|
if command -v setfacl >/dev/null 2>&1; then
|
|
### Fix the folder permissions so the active user (1000) can access the files
|
|
progressSwitchOn
|
|
{
|
|
sudo setfacl -R -m u:"$USER":rwx "${VDM_PROJECT_PATH}/${persistent}/joomla"
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the permissions of ${persistent} Joomla so user:$USER can access and edit them both the files and folders."
|
|
else
|
|
showError "[ERROR] Could not fix the permissions of the ${persistent} Joomla so user:$USER can access them.\n\n\
|
|
You will need to install: setfacl for this option to work, then run this fix again."
|
|
fi
|
|
elif command -v setfacl >/dev/null 2>&1; then
|
|
# we remove the acl map if it was set before
|
|
sudo setfacl -R -b "${VDM_PROJECT_PATH}/${persistent}/joomla"
|
|
fi
|
|
### Fix the folder ownership of database folders
|
|
# id -u systemd-coredump
|
|
# id -g systemd-coredump
|
|
#
|
|
progressSwitchOn
|
|
{
|
|
sudo chown -R 999:999 "${VDM_PROJECT_PATH}/${persistent}/db"
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the ownership of ${persistent} database directory/files.\n(chown -R 999:999 ${persistent}/db)"
|
|
### Fix the folder permissions for the database files
|
|
#
|
|
# Change the file permissions
|
|
progressSwitchOn
|
|
{
|
|
sudo find "${VDM_PROJECT_PATH}/${persistent}/db" -type f -exec chmod 660 {} \;
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the file permissions for the ${persistent} database.\n(find ${persistent}/db -type f -exec chmod 660 {} \;)"
|
|
progressSwitchOn
|
|
{
|
|
sudo find "${VDM_PROJECT_PATH}/${persistent}/db" -type d -exec chmod 700 {} \;
|
|
progressSwitchOff
|
|
} &
|
|
showProgress "Setting the directory permissions for the ${persistent} database.\n(find ${persistent}/db -type d -exec chmod 700 {} \;)"
|
|
# show the completion of this permission fix
|
|
showNotice "Permissions update completed!"
|
|
else
|
|
showError "${VDM_PROJECT_PATH}/${persistent} is not a joomla persistent volume and was skipped."
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# delete persistent volumes
|
|
function deletePersistentVolumes() {
|
|
# we first check if we have some volumes
|
|
if hasDirectories '' "${VDM_PROJECT_PATH}"; then
|
|
# set some local variables
|
|
local vdm_delete_volumes
|
|
local persistent
|
|
# saved the file
|
|
showNotice "Only delete persistent volumes of which you have made absolutely sure it's no longer in use!"
|
|
# get containers to enable
|
|
vdm_delete_volumes=$(getSelectedDirectories "Select persistent volume\s to delete." \
|
|
"${VDM_PROJECT_PATH}" "Select Persistent Volume\s to Delete")
|
|
# check that we have something, else return to main menu
|
|
if [ ${#vdm_delete_volumes} -ge 1 ]; then
|
|
# convert the string to and array
|
|
IFS=' ' read -r -a vdm_delete_volumes_array <<<"${vdm_delete_volumes[@]}"
|
|
# loop over the directories to build the
|
|
for volumes in "${vdm_delete_volumes_array[@]}"; do
|
|
# remove the " from the string
|
|
persistent="${volumes//\"/}"
|
|
# last serious check and then its gone
|
|
if [ -d "${VDM_PROJECT_PATH}/${persistent}" ] &&
|
|
(whiptail --yesno "Are you absolutely sure you would like to delete this (${persistent}) persistent volume? THIS CAN'T BE UNDONE!\n(we need sudo privileges)" \
|
|
--title "Delete Persistent Volume" --backtitle "${BACK_TITLE}" 15 112); then
|
|
# then remove soft link
|
|
sudo rm -rf "${VDM_PROJECT_PATH}/${persistent}"
|
|
fi
|
|
done
|
|
fi
|
|
else
|
|
showError "There are no persistent volumes found in ${VDM_PROJECT_PATH}."
|
|
fi
|
|
}
|
|
|
|
# make an update
|
|
function runUpdate() {
|
|
# we need sudo permissions
|
|
if (whiptail --yesno "${USER^}, to update ${PROGRAM_NAME} we need sudo privileges." \
|
|
--title "Give sudo Privileges" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# remove the current version
|
|
if [ -f /usr/local/bin/octojoom ]; then
|
|
# just backup in case of failure
|
|
sudo mv /usr/local/bin/octojoom /usr/local/bin/octojoom.bak
|
|
fi
|
|
# some local values
|
|
local branch
|
|
# get the target branch to use in our update
|
|
isExpert && branch=$(getTargetBranch)
|
|
# pull the latest version. Master is always the latest
|
|
if sudo curl --fail -L "https://git.vdm.dev/api/v1/repos/octoleo/octojoom/raw/src/octojoom?ref=${branch:-master}" -o /usr/local/bin/octojoom 2>/dev/null; then
|
|
# give success message
|
|
echo "SUCCESS: Update was successful."
|
|
# do we have a backup
|
|
if [ -f /usr/local/bin/octojoom.bak ]; then
|
|
# lets remove it now
|
|
sudo rm -f /usr/local/bin/octojoom.bak
|
|
fi
|
|
else
|
|
# show the error
|
|
echo >&2 "ERROR: Update failed! Please try again later."
|
|
# do we have a backup
|
|
if [ -f /usr/local/bin/octojoom.bak ]; then
|
|
# move backup back
|
|
sudo mv /usr/local/bin/octojoom.bak /usr/local/bin/octojoom
|
|
fi
|
|
fi
|
|
# always set the permission again if we have a file
|
|
if [ -f /usr/local/bin/octojoom ]; then
|
|
# the we make sure its executable
|
|
sudo chmod +x /usr/local/bin/octojoom
|
|
fi
|
|
# always exit so the new script can load
|
|
quitProgram
|
|
fi
|
|
}
|
|
|
|
# make an uninstall
|
|
function runUninstall() {
|
|
# little notice
|
|
showNotice "We have three uninstall options: 1) Complete. 2) Just Script. 3) Make your selection."
|
|
# first safety check
|
|
if (whiptail --yesno "We are just trying to be careful here, therefore we have a few questions. Please remember there is an auto update option!\n\
|
|
Are you absolutely sure you want to continue with the uninstalling process?\n(we need sudo privileges)" \
|
|
--defaultno --title "Uninstalling ${PROGRAM_NAME} v${_VERSION} " --backtitle "${BACK_TITLE}" 15 112); then
|
|
# we have four main options
|
|
if (whiptail --yesno "Okay, So do you want to completely remove everything? This is the most dangerous option! IT CAN'T BE UNDONE!\
|
|
We will remove literally everything like this script was never here." \
|
|
--defaultno --title "Complete Uninstall of ${PROGRAM_NAME} v${_VERSION} " --backtitle "${BACK_TITLE}" 12 112); then
|
|
if [ -d "${VDM_REPO_PATH}/joomla" ]; then
|
|
# take down all joomla containers
|
|
downContainers 'joomla'
|
|
# now completely remove Joomla configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/joomla"
|
|
fi
|
|
# Remove all of Openssh Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/openssh" ]; then
|
|
# take down all joomla containers
|
|
downContainers 'openssh'
|
|
# now completely remove Joomla configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/openssh"
|
|
fi
|
|
# Remove all of Portainer Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/portainer" ]; then
|
|
# take down all portainer containers
|
|
disableContainer 'portainer'
|
|
# now completely remove Portainer configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/portainer"
|
|
fi
|
|
# Remove all of Traefik Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/traefik" ]; then
|
|
# take down all traefik containers
|
|
disableContainer 'traefik'
|
|
# now completely remove Traefik configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/traefik"
|
|
fi
|
|
# remove config if found
|
|
if [ -d "${VDM_SRC_PATH}" ]; then
|
|
sudo rm -fr "${VDM_SRC_PATH}"
|
|
fi
|
|
# remove config if found
|
|
if [ -d "${VDM_REPO_PATH}" ]; then
|
|
sudo rm -fr "${VDM_REPO_PATH}"
|
|
fi
|
|
elif (whiptail --yesno "Would you like to only remove the actual ${PROGRAM_NAME} v${_V} script but keep all the Docker stuff?" \
|
|
--title "Keep Docker Stuff" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# now remove the octojoom script
|
|
if [ -f /usr/local/bin/octojoom ]; then
|
|
sudo rm -f /usr/local/bin/octojoom
|
|
fi
|
|
# give the final message
|
|
whiptail --title "${PROGRAM_NAME} v${_VERSION} is UNINSTALLED" --msgbox "\n\
|
|
${PROGRAM_NAME} v${_V} has been uninstalled.\n\n\
|
|
We have not touched any of the Docker stuff.\n\
|
|
To also remove these you will have to manually pull down the Docker containers (if there are any running) and then remove the following directories.\n\n\
|
|
DOCKER: ${VDM_REPO_PATH} \n\
|
|
VOLUMES: ${VDM_PROJECT_PATH} \n\
|
|
CONFIG: ${VDM_SRC_PATH}" --backtitle "${BACK_TITLE}" 20 112
|
|
# we exit here... where done!
|
|
quitProgram
|
|
else
|
|
# little notice
|
|
showNotice "This option lets you choose what you keep, so read the questions carefully! IT CAN'T BE UNDONE!"
|
|
# shellcheck disable=SC1090
|
|
# ----------------------------------------------------- MULTI CONTAINERS
|
|
# Remove all of Joomla Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/joomla" ] &&
|
|
(whiptail --yesno "Would you like to completely remove the Joomla Docker yaml configurations in (${VDM_REPO_PATH}/joomla)?" \
|
|
--defaultno --title "Remove Docker Config" --backtitle "${BACK_TITLE}" 12 112); then
|
|
# take down all joomla containers
|
|
downContainers 'joomla'
|
|
# now completely remove Joomla configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/joomla"
|
|
fi
|
|
# check if we have possible joomla containers (this will only run if they did not remove it above)
|
|
if [ -e "${VDM_REPO_PATH}/joomla/enabled" ] &&
|
|
(whiptail --yesno "Would you like to take down Joomla containers?" \
|
|
--defaultno --title "Take Down Containers" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# take down all joomla containers
|
|
downContainers 'joomla'
|
|
# remove all enabled
|
|
sudo rm -fr "${VDM_REPO_PATH}/joomla/enabled"
|
|
fi
|
|
# Remove all of Openssh Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/openssh" ] &&
|
|
(whiptail --yesno "Would you like to completely remove the Openssh Docker yaml configurations in (${VDM_REPO_PATH}/openssh)?" \
|
|
--defaultno --title "Remove Docker Config" --backtitle "${BACK_TITLE}" 12 112); then
|
|
# take down all joomla containers
|
|
downContainers 'openssh'
|
|
# now completely remove Joomla configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/openssh"
|
|
fi
|
|
# check if we have possible openssh containers (this will only run if they did not remove it above)
|
|
if [ -e "${VDM_REPO_PATH}/openssh/enabled" ] &&
|
|
(whiptail --yesno "Would you like to take down Openssh containers?" \
|
|
--defaultno --title "Take Down Containers" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# take down all joomla containers
|
|
downContainers 'openssh'
|
|
# remove all enabled
|
|
sudo rm -fr "${VDM_REPO_PATH}/openssh/enabled"
|
|
fi
|
|
# ----------------------------------------------------- SINGLE CONTAINER
|
|
# Remove all of Portainer Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/portainer" ] &&
|
|
(whiptail --yesno "Would you like to completely remove the Portainer Docker yaml configurations in (${VDM_REPO_PATH}/portainer)?" \
|
|
--defaultno --title "Remove Docker Config" --backtitle "${BACK_TITLE}" 12 112); then
|
|
# take down all portainer containers
|
|
disableContainer 'portainer'
|
|
# now completely remove Portainer configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/portainer"
|
|
fi
|
|
# check if we have possible portainer container (this will only run if they did not remove it above)
|
|
if [ -f "${VDM_REPO_PATH}/portainer/docker-compose.yml" ] &&
|
|
(whiptail --yesno "Would you like to take down Portainer container?" \
|
|
--defaultno --title "Take Down Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# take down the container
|
|
disableContainer 'portainer'
|
|
fi
|
|
# Remove all of Traefik Docker stuff
|
|
if [ -d "${VDM_REPO_PATH}/traefik" ] &&
|
|
(whiptail --yesno "Would you like to completely remove the Traefik Docker yaml configurations in (${VDM_REPO_PATH}/traefik)?" \
|
|
--defaultno --title "Remove Docker Config" --backtitle "${BACK_TITLE}" 12 112); then
|
|
# take down all traefik containers
|
|
disableContainer 'traefik'
|
|
# now completely remove Traefik configurations
|
|
sudo rm -fr "${VDM_REPO_PATH}/traefik"
|
|
fi
|
|
# check if we have possible traefik container (this will only run if they did not remove it above)
|
|
if [ -f "${VDM_REPO_PATH}/traefik/docker-compose.yml" ] &&
|
|
(whiptail --yesno "Would you like to take down Traefik container?" \
|
|
--defaultno --title "Take Down Container" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# take down the container
|
|
disableContainer 'traefik'
|
|
fi
|
|
# remove config if found
|
|
if [ -d "${VDM_SRC_PATH}" ] &&
|
|
(whiptail --yesno "Would you like to remove the global docker configurations?" \
|
|
--defaultno --title "Remove Docker Config" --backtitle "${BACK_TITLE}" 8 112); then
|
|
sudo rm -fr "${VDM_SRC_PATH}"
|
|
fi
|
|
fi
|
|
# now remove the octojoom script
|
|
if [ -f /usr/local/bin/octojoom ]; then
|
|
sudo rm -f /usr/local/bin/octojoom
|
|
fi
|
|
# last and final question as this is most dangerous and serious issue.
|
|
if [ -d "${VDM_PROJECT_PATH}" ] &&
|
|
(whiptail --yesno "Last question, would you like to remove all persistent volumes of your containers in (${VDM_PROJECT_PATH})?" \
|
|
--defaultno --title "Completely DELETE persistent volumes" --backtitle "${BACK_TITLE}" 12 112); then
|
|
sudo rm -rf "${VDM_PROJECT_PATH}"
|
|
fi
|
|
# give the final message
|
|
whiptail --title "${PROGRAM_NAME} v${_VERSION} is UNINSTALLED" --msgbox "\n\n\
|
|
${PROGRAM_NAME} v${_V} has been uninstalled." --backtitle "${BACK_TITLE}" 10 112
|
|
# exit the program right now
|
|
quitProgram
|
|
fi
|
|
}
|
|
|
|
# we show the octoleo info quietly
|
|
octojoomQuietly() {
|
|
local message
|
|
# now set the message
|
|
message=" https://git.vdm.dev/octoleo/octojoom
|
|
|
|
Welcome to an Octoleo Program (${PROGRAM_NAME} v$_VERSION)
|
|
|
|
Description
|
|
With this script we can easily deploy docker containers of Joomla and Openssh.
|
|
This combination of these tools give rise to a powerful and very secure shared
|
|
development environment.
|
|
This program has **command input** options as seen in the menus item called
|
|
**Show command help**, but these commands are _not the only way_ to set these
|
|
values. When the values are **omitted** you will be _asked in the terminal_ to
|
|
manually enter the required values as needed. Furthermore, the use of
|
|
**env variables** are also heavily used across the script. There are more
|
|
than one .env file and the script will set those up for you whenever you run a
|
|
task that make use of env variables. The script will check if those values exist,
|
|
and if they don't it will ask for them, and store them automatically for future use.
|
|
That same time the output message to the terminal will show you where the specific
|
|
.env file can be found.
|
|
|
|
Author Licence
|
|
Llewellyn van der Merwe <octoleo@vdm.io> GNU GENERAL PUBLIC LICENSE Version 2
|
|
|
|
--quiet"
|
|
|
|
whiptail --msgbox "${message}" --fb --backtitle "${BACK_TITLE}" 32 112
|
|
}
|
|
|
|
# show the commands help menu
|
|
function showCommandsHelpMenu() {
|
|
help=$(showHelp)
|
|
whiptail --msgbox --scrolltext "${help}" --fb --backtitle "${BACK_TITLE}" 30 90
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## MENUS
|
|
|
|
# show Joomla menu
|
|
function showJoomla() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=3
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.")
|
|
# setup new container
|
|
menu_options+=("setup" "Setup new container")
|
|
# enable existing container
|
|
hasDirectories 'joomla/available' &&
|
|
menu_options+=("enable" "Enable existing container") && i=$((i + 1))
|
|
# disable enabled container
|
|
hasDirectories 'joomla/enabled' &&
|
|
menu_options+=("disable" "Disable enabled container") && i=$((i + 1))
|
|
# take all enabled containers down
|
|
hasDirectories 'joomla/enabled' &&
|
|
menu_options+=("down" "Take all enabled containers down") && i=$((i + 1))
|
|
# pull up all enabled containers
|
|
hasDirectories 'joomla/enabled' &&
|
|
menu_options+=("up" "Pull up all enabled containers") && i=$((i + 1))
|
|
# edit available container
|
|
isExpert && hasDirectories 'joomla/available' &&
|
|
menu_options+=("edit" "Edit available container") && i=$((i + 1))
|
|
# fix permissions
|
|
hasDirectories '' "${VDM_PROJECT_PATH}" &&
|
|
menu_options+=("fix" "Fix permissions of folders and files of a container") &&
|
|
i=$((i + 1))
|
|
# delete a container
|
|
hasDirectories 'joomla/available' &&
|
|
menu_options+=("delete" "Delete a container") && i=$((i + 1))
|
|
# Get Joomla env details
|
|
isExpert && hasDirectories 'joomla/available' &&
|
|
menu_options+=("joomla_env" "Open Joomla .env Details") && i=$((i + 1))
|
|
# bulk deploy
|
|
isExpert && menu_options+=("bulk" "Bulk deploy") && i=$((i + 1))
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Joomla | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
# menu actions
|
|
case $CHOICE in
|
|
"setup")
|
|
setupContainer 'joomla'
|
|
;;
|
|
"edit")
|
|
editContainer 'joomla'
|
|
;;
|
|
"enable")
|
|
enableContainer 'joomla'
|
|
;;
|
|
"disable")
|
|
disableContainer 'joomla'
|
|
;;
|
|
"down")
|
|
downContainers 'joomla'
|
|
;;
|
|
"up")
|
|
upContainers 'joomla'
|
|
;;
|
|
"fix")
|
|
fixContainersPermissions
|
|
;;
|
|
"delete")
|
|
deleteContainer 'joomla'
|
|
;;
|
|
"joomla_env")
|
|
openEnv 'joomla'
|
|
;;
|
|
"bulk")
|
|
bulkSetupContainers 'joomla'
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"setup" | "edit" | "enable" | "disable" | "down" | "up" | "fix" | "delete" | "joomla_env" | "bulk")
|
|
showJoomla
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# show Openssh menu
|
|
function showOpenssh() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=3
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.")
|
|
# setup new container
|
|
menu_options+=("setup" "Setup new container")
|
|
# enable existing container
|
|
hasDirectories 'openssh/available' &&
|
|
menu_options+=("enable" "Enable existing container") && i=$((i + 1))
|
|
# disable enabled container
|
|
hasDirectories 'openssh/enabled' &&
|
|
menu_options+=("disable" "Disable enabled container") && i=$((i + 1))
|
|
# take all enabled containers down
|
|
hasDirectories 'openssh/enabled' &&
|
|
menu_options+=("down" "Take all enabled containers down") && i=$((i + 1))
|
|
# pull up all enabled containers
|
|
hasDirectories 'openssh/enabled' &&
|
|
menu_options+=("up" "Pull up all enabled containers") && i=$((i + 1))
|
|
# edit available container
|
|
isExpert && hasDirectories 'openssh/available' &&
|
|
menu_options+=("edit" "Edit available container") && i=$((i + 1))
|
|
# delete a container
|
|
hasDirectories 'openssh/available' &&
|
|
menu_options+=("delete" "Delete a container") && i=$((i + 1))
|
|
# Get Openssh env details
|
|
isExpert && hasDirectories 'openssh/available' &&
|
|
menu_options+=("openssh_env" "Open Openssh .env Details") && i=$((i + 1))
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Openssh | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
case $CHOICE in
|
|
"setup")
|
|
setupContainer 'openssh'
|
|
;;
|
|
"edit")
|
|
editContainer 'openssh'
|
|
;;
|
|
"enable")
|
|
enableContainer 'openssh'
|
|
;;
|
|
"disable")
|
|
disableContainer 'openssh'
|
|
;;
|
|
"down")
|
|
downContainers 'openssh'
|
|
;;
|
|
"up")
|
|
upContainers 'openssh'
|
|
;;
|
|
"delete")
|
|
deleteContainer 'openssh'
|
|
;;
|
|
"openssh_env")
|
|
openEnv 'openssh'
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"setup" | "edit" | "enable" | "disable" | "down" | "up" | "delete" | "openssh_env" )
|
|
showOpenssh
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# show Traefik menu
|
|
function showTraefik() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=3
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.") && i=$((i + 1))
|
|
# setup new container
|
|
menu_options+=("setup" "Setup or rebuild Traefik")
|
|
# enable existing container
|
|
[ -f "${VDM_REPO_PATH}/traefik/docker-compose.yml" ] &&
|
|
menu_options+=("enable" "Enable Traefik") && i=$((i + 1))
|
|
# disable enabled container
|
|
[ -f "${VDM_REPO_PATH}/traefik/docker-compose.yml" ] &&
|
|
menu_options+=("disable" "Disable Traefik") && i=$((i + 1))
|
|
# edit available container
|
|
isExpert && [ -f "${VDM_REPO_PATH}/traefik/docker-compose.yml" ] &&
|
|
menu_options+=("edit" "Edit Traefik") && i=$((i + 1))
|
|
# delete traefik container
|
|
[ -f "${VDM_REPO_PATH}/traefik/docker-compose.yml" ] &&
|
|
menu_options+=("delete" "Delete Traefik") && i=$((i + 1))
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Traefik | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
# menu actions
|
|
case $CHOICE in
|
|
"setup")
|
|
setupContainer 'traefik'
|
|
;;
|
|
"edit")
|
|
editContainer 'traefik'
|
|
;;
|
|
"enable")
|
|
enableContainer 'traefik'
|
|
;;
|
|
"disable")
|
|
disableContainer 'traefik'
|
|
;;
|
|
"delete")
|
|
deleteContainer 'traefik'
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"setup" | "edit" | "enable" | "disable" | "delete")
|
|
showTraefik
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# show Portainer menu
|
|
function showPortainer() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=3
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.")
|
|
# setup new container
|
|
menu_options+=("setup" "Setup or rebuild Portainer")
|
|
# enable existing container
|
|
[ -f "${VDM_REPO_PATH}/portainer/docker-compose.yml" ] &&
|
|
menu_options+=("enable" "Enable Portainer") && i=$((i + 1))
|
|
# disable enabled container
|
|
[ -f "${VDM_REPO_PATH}/portainer/docker-compose.yml" ] &&
|
|
menu_options+=("disable" "Disable Portainer") && i=$((i + 1))
|
|
# edit available container
|
|
isExpert && [ -f "${VDM_REPO_PATH}/portainer/docker-compose.yml" ] &&
|
|
menu_options+=("edit" "Edit Portainer") && i=$((i + 1))
|
|
# delete traefik container
|
|
[ -f "${VDM_REPO_PATH}/portainer/docker-compose.yml" ] &&
|
|
menu_options+=("delete" "Delete Portainer") && i=$((i + 1))
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Portainer | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
# menu actions
|
|
case $CHOICE in
|
|
"setup")
|
|
setupContainer 'portainer'
|
|
;;
|
|
"edit")
|
|
editContainer 'portainer'
|
|
;;
|
|
"enable")
|
|
enableContainer 'portainer'
|
|
;;
|
|
"disable")
|
|
disableContainer 'portainer'
|
|
;;
|
|
"delete")
|
|
deleteContainer 'portainer'
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"setup" | "edit" | "enable" | "disable" | "delete")
|
|
showPortainer
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# show systems help menu
|
|
function showSettings() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=8
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.")
|
|
# the mode switch
|
|
isExpert && menu_options+=("basic-mode" "Switch to basic mode")
|
|
! isExpert && menu_options+=("expert-mode" "Switch to expert mode")
|
|
i=$((i + 1))
|
|
# Show command help
|
|
menu_options+=("command-help" "Help with commands")
|
|
# Show folder paths
|
|
menu_options+=("important-paths" "Important paths")
|
|
# Edit the global config
|
|
isExpert && [ -f "${VDM_SRC_PATH}/.env" ] &&
|
|
menu_options+=("edit-config" "Edit Config") && i=$((i + 1))
|
|
# the remote-control option
|
|
isExpert && menu_options+=("remote" "Access Remote ${PROGRAM_NAME}") && i=$((i + 1))
|
|
# Report an Issue
|
|
menu_options+=("report-issue" "Report an issue")
|
|
# Update the whole script
|
|
menu_options+=("update" "Update ${PROGRAM_NAME,,}")
|
|
# Uninstall the whole script
|
|
menu_options+=("uninstall" "Uninstall ${PROGRAM_NAME,,}")
|
|
# Octoleo details
|
|
menu_options+=("octojoom" "${PROGRAM_NAME}")
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Settings Menu | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
# menu actions
|
|
case $CHOICE in
|
|
"basic-mode")
|
|
setMode 'basic'
|
|
;;
|
|
"expert-mode")
|
|
setMode 'expert'
|
|
;;
|
|
"command-help")
|
|
showCommandsHelpMenu
|
|
;;
|
|
"important-paths")
|
|
showImportantPaths
|
|
;;
|
|
"edit-config")
|
|
editConfigFile
|
|
;;
|
|
"remote")
|
|
hasRemoteSystemSet && connectToRemoteSystem
|
|
;;
|
|
"report-issue")
|
|
showLink "https://git.vdm.dev/octoleo/octojoom/issues" "To report an issue go to:" "Report an Issue"
|
|
;;
|
|
"update")
|
|
runUpdate
|
|
;;
|
|
"uninstall")
|
|
runUninstall
|
|
;;
|
|
"octojoom")
|
|
octojoomQuietly
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"basic-mode" | "expert-mode" | "command-help" | "important-paths" | "edit-config" | "report-issue" | "octojoom" | "remote")
|
|
showSettings
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# show domains menu
|
|
function domainsMenu() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=3
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.")
|
|
# add more domains
|
|
allowMultiDomains &&
|
|
menu_options+=("add" "Add Domain") && i=$((i + 1))
|
|
# remove existing domains
|
|
[ -f "${VDM_SRC_PATH}/.domains" ] &&
|
|
menu_options+=("delete" "Delete Domain") && i=$((i + 1))
|
|
# edit available container
|
|
isExpert && allowEditHostFile &&
|
|
menu_options+=("edit" "Edit Host File") && i=$((i + 1))
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Domains Menu | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
# menu actions
|
|
case $CHOICE in
|
|
"add")
|
|
setMultiDomains
|
|
;;
|
|
"delete")
|
|
deleteMultiDomains
|
|
;;
|
|
"edit")
|
|
editHostFile
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"add" | "delete" | "edit")
|
|
domainsMenu
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# show migration menu
|
|
function migrateMenu() {
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=4
|
|
# load the back menu
|
|
menu_options+=("back" "<-- Return to the main menu.")
|
|
# Select a joomla container to migrate
|
|
menu_options+=("joomla" "Migrate Joomla Container")
|
|
# Select a openssh container to migrate
|
|
menu_options+=("openssh" "Migrate Openssh Container")
|
|
# Select project directories to migrate
|
|
hasDirectories '' "${VDM_PROJECT_PATH}" &&
|
|
menu_options+=("directory" "Migrate Project Directory") && i=$((i + 1))
|
|
# the remote-control option
|
|
isExpert && menu_options+=("remote" "Access Remote ${PROGRAM_NAME}") && i=$((i + 1))
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
# get the selection
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "Migration Menu | ${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
# menu actions
|
|
case $CHOICE in
|
|
"joomla")
|
|
migrateContainer 'joomla'
|
|
;;
|
|
"openssh")
|
|
migrateContainer 'openssh'
|
|
;;
|
|
"directory")
|
|
migrateContainer 'directory'
|
|
;;
|
|
"remote")
|
|
connectToRemoteSystem
|
|
;;
|
|
"quit") quitProgram
|
|
;;
|
|
esac
|
|
|
|
# menu loop
|
|
case $CHOICE in
|
|
"joomla" | "openssh" | "directory" | "remote")
|
|
migrateMenu
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# MAIN MENU
|
|
function mainMenu() {
|
|
# get the selection
|
|
while true; do
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=6
|
|
# Joomla containers
|
|
menu_options+=("joomla" "Joomla Containers")
|
|
# Openssh containers
|
|
menu_options+=("openssh" "Openssh Containers")
|
|
# Traefik container
|
|
menu_options+=("traefik" "Traefik Container")
|
|
# Portainer container
|
|
menu_options+=("portainer" "Portainer Container")
|
|
# Manage Domains
|
|
if isExpert && (allowEditHostFile || allowMultiDomains); then
|
|
menu_options+=("domains" "Manage Domains")
|
|
i=$((i + 1))
|
|
fi
|
|
# Migrate available container
|
|
isExpert &&
|
|
menu_options+=("migrate" "Migration Options") && i=$((i + 1))
|
|
# Delete Persistent Volumes
|
|
isExpert && hasDirectories '' "${VDM_PROJECT_PATH}" &&
|
|
menu_options+=("delete" "Delete Persistent Volumes") && i=$((i + 1))
|
|
# Octoleo settings
|
|
menu_options+=("settings" "${PROGRAM_NAME} Settings")
|
|
# Quit Octoleo Program
|
|
menu_options+=("quit" "Quit ${PROGRAM_NAME}")
|
|
|
|
CHOICE=$(
|
|
whiptail --menu "Make your selection" 20 112 $i \
|
|
--title "${PROGRAM_NAME} v${_V}" --fb \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"${menu_options[@]}" 3>&2 2>&1 1>&3
|
|
)
|
|
|
|
case $CHOICE in
|
|
"joomla")
|
|
showJoomla
|
|
;;
|
|
"openssh")
|
|
showOpenssh
|
|
;;
|
|
"traefik")
|
|
showTraefik
|
|
;;
|
|
"portainer")
|
|
showPortainer
|
|
;;
|
|
"domains")
|
|
domainsMenu
|
|
;;
|
|
"migrate")
|
|
hasRemoteSystemSet && migrateMenu
|
|
;;
|
|
"delete")
|
|
deletePersistentVolumes
|
|
;;
|
|
"settings")
|
|
showSettings
|
|
;;
|
|
"quit") quitProgram ;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## GENERAL SHARED FUNCTIONS
|
|
|
|
# show error
|
|
function showError() {
|
|
whiptail --title "ERROR | ${PROGRAM_NAME} v${_V}" --backtitle "${BACK_TITLE}" \
|
|
--msgbox "${1}" "${2:-12}" 112
|
|
}
|
|
|
|
# show info
|
|
function showInfo() {
|
|
whiptail --title "INFO | ${PROGRAM_NAME} v${_V}" --backtitle "${BACK_TITLE}" \
|
|
--infobox "${1}" "${2:-12}" 112
|
|
}
|
|
|
|
# show notice
|
|
function showNotice() {
|
|
whiptail --title "NOTICE | ${PROGRAM_NAME} v${_V}" --backtitle "${BACK_TITLE}" \
|
|
--msgbox "${1}" "${2:-12}" 112
|
|
}
|
|
|
|
# show link
|
|
function showLink() {
|
|
whiptail --title "${3:-Open Link} | ${PROGRAM_NAME} v${_V}" --backtitle "${BACK_TITLE}" \
|
|
--msgbox "${2:-To open the link click here:} ${1}" 8 112
|
|
}
|
|
|
|
# show progress bar
|
|
function showProgress() {
|
|
# some locals
|
|
local title
|
|
local message
|
|
local per
|
|
# get input
|
|
message="$1"
|
|
title="${2:-Please wait!}"
|
|
# our little loop progress
|
|
{
|
|
per=1
|
|
while (true); do
|
|
if ! inProgress; then
|
|
# we are finished, so we slow down to 100%
|
|
sleep .2
|
|
echo 88
|
|
sleep .2
|
|
echo 90
|
|
sleep .$((1 + "$RANDOM" % 6))
|
|
echo 98
|
|
sleep .$((1 + "$RANDOM" % 5))
|
|
echo 100
|
|
sleep .$((1 + "$RANDOM" % 5))
|
|
break
|
|
elif [[ "87" -eq "$per" ]]; then
|
|
# if it takes longer we loop
|
|
per="33"
|
|
fi
|
|
# sleep a little moment
|
|
sleep .$((1 + "$RANDOM" % 9))
|
|
echo $per
|
|
per=$((per + 1))
|
|
done
|
|
} | whiptail --title "${title}" --gauge "${message}" --backtitle "${BACK_TITLE}" 8 112 0
|
|
}
|
|
|
|
# turn on progress
|
|
function progressSwitchOn() {
|
|
echo "Progress ON" >"${VDM_SRC_PATH}/.progress"
|
|
}
|
|
|
|
# switch off the progress
|
|
function progressSwitchOff() {
|
|
rm -f "${VDM_SRC_PATH}/.progress"
|
|
}
|
|
|
|
# get the progress
|
|
function inProgress() {
|
|
if [ -f "${VDM_SRC_PATH}/.progress" ]; then
|
|
# found it
|
|
return 0
|
|
fi
|
|
# did not find it
|
|
return 1
|
|
}
|
|
|
|
# show important paths
|
|
function showImportantPaths() {
|
|
local message
|
|
# now set the message
|
|
message=" ${PROGRAM_NAME} v$_VERSION
|
|
|
|
We have a few important paths that you should know, and use to manually manage your setup.
|
|
|
|
DOCKER: ${VDM_REPO_PATH}
|
|
SOURCE: ${VDM_SRC_PATH}/.images-source
|
|
DOMAINS: ${VDM_SRC_PATH}/.domains
|
|
CONFIG: ${VDM_SRC_PATH}/.env
|
|
SSH: ${VDM_REPO_PATH}/openssh/.ssh
|
|
VOLUMES: ${VDM_PROJECT_PATH}
|
|
|
|
Then we have some key environment variable files that hold very useful and important information.
|
|
Since we do not store any passwords or other important details in the docker-compose.yml files
|
|
they are stored in >>these environment variable files<< and therefore we set these .env file
|
|
permission to (600) for security.
|
|
|
|
JOOMLA: ${VDM_REPO_PATH}/joomla/.env
|
|
OPENSSH: ${VDM_REPO_PATH}/openssh/.env
|
|
TRAEFIK: ${VDM_REPO_PATH}/traefik/.env
|
|
PORTAINER: ${VDM_REPO_PATH}/portainer/.env
|
|
|
|
|
|
Not all these files or folders may exist, they are created only when needed.
|
|
"
|
|
|
|
whiptail --msgbox "${message}" --fb --backtitle "${BACK_TITLE}" 32 112
|
|
}
|
|
|
|
# show show the Joomla config details
|
|
function showJoomlaConfigDetails() {
|
|
# load the env back to show if set previously
|
|
# shellcheck disable=SC1090
|
|
# [ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ] && source "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# set some locals
|
|
local message
|
|
# now set the message
|
|
message=" ${PROGRAM_NAME} v$_VERSION
|
|
|
|
Running the Joomla container for the first time you will need these details:
|
|
--------------------------------------------------------------------
|
|
URL: ${VDM_HTTP_SCHEME}${VDM_SUBDOMAIN}.${VDM_DOMAIN}
|
|
DATABASE_HOST: mariadb${VDM_KEY}:3306
|
|
--------------------------------------------------------------------
|
|
VDM_${VDM_ENV_KEY^^}_DB: ${vdm_database_name}
|
|
VDM_${VDM_ENV_KEY^^}_DB_USER: ${vdm_database_user}
|
|
VDM_${VDM_ENV_KEY^^}_DB_PASS: ${vdm_database_pass}
|
|
VDM_${VDM_ENV_KEY^^}_DB_ROOT: ${vdm_database_rootpass}
|
|
--------------------------------------------------------------------
|
|
These details are securely stored in this environment variable file
|
|
${VDM_REPO_PATH}/joomla/.env
|
|
--------------------------------------------------------------------
|
|
|
|
Do not remove these details from the file, as it's used to deploy the container.
|
|
"
|
|
|
|
whiptail --msgbox "${message}" --fb --backtitle "${BACK_TITLE}" 30 112
|
|
}
|
|
|
|
# we must get a random key
|
|
function getRandomPass() {
|
|
local length="${1:-128}"
|
|
tr -dc 'A-HJ-NP-Za-km-z2-9' </dev/urandom | head -c "$length"
|
|
}
|
|
|
|
# we must get a random key
|
|
function getRandomName() {
|
|
local length="${1:-128}"
|
|
tr -dc 'A-Za-z' </dev/urandom | head -c "$length"
|
|
}
|
|
|
|
# Get input from the user using whiptail utility
|
|
# $1: Prompt message
|
|
# $2 (optional): Default input value
|
|
# $3 (optional): Title for the input dialog
|
|
function getInput() {
|
|
# set local var
|
|
local answer
|
|
# get the answer
|
|
answer=$(whiptail --inputbox "$1" 10 112 "${2:-}" --title "${3:-Get Input}" \
|
|
--backtitle "${BACK_TITLE}" --nocancel 3>&1 1>&2 2>&3)
|
|
# return the answer
|
|
echo "${answer}"
|
|
}
|
|
|
|
# get the input until is gotten
|
|
function getInputNow() {
|
|
local message
|
|
local default
|
|
local title
|
|
local answer=""
|
|
# get the values
|
|
message="${1:-Enter a value}"
|
|
default="${2:-}"
|
|
title="${3:-value}"
|
|
# get the value if not already set
|
|
while [ -z "$answer" ] || [ ${#answer} -le 1 ]; do
|
|
# get the value
|
|
answer=$(getInput "${message}" \
|
|
"${default}" "${title}")
|
|
# keep asking if empty or does exist
|
|
if [ ${#answer} -le 1 ]; then
|
|
showError "You must enter a $title"
|
|
fi
|
|
done
|
|
# return the answer
|
|
echo "${answer}"
|
|
}
|
|
|
|
# get a selected directory
|
|
function getSelectedDirectory() {
|
|
# the selected folder
|
|
local answer
|
|
# set the local path
|
|
local path="${2:-}"
|
|
# set local var
|
|
local folder="${3:-}"
|
|
# we start the selection array
|
|
local selected=()
|
|
# our counter
|
|
local i=0
|
|
# whiptail box size details
|
|
local description_lines
|
|
local height
|
|
# now check if this dir has sub dirs
|
|
if hasDirectories '' "$path"; then
|
|
# loop over the directory
|
|
for dir_ in "${path%/}/"*; do
|
|
# remove the full path
|
|
dir_="${dir_/$path/}"
|
|
# load the selection
|
|
[ "$folder" = "${dir_#/}" ] && selected+=("${dir_#/}" "${dir_#/}" "ON") || selected+=("${dir_#/}" "${dir_#/}" "OFF")
|
|
# increment our pointer
|
|
if [ "$i" -le 10 ]; then
|
|
i=$((i + 1))
|
|
fi
|
|
done
|
|
|
|
# Calculate the height based on the description length and directory count
|
|
description_lines=$(echo -e "${1}" | wc -l)
|
|
height=$((description_lines + i + 7))
|
|
|
|
# now make the selection
|
|
answer=$(whiptail --title "${4:-Make a Selection}" --radiolist \
|
|
"${1}" $height 112 $i \
|
|
"${selected[@]}" --backtitle "${BACK_TITLE}" --nocancel --notags 3>&1 1>&2 2>&3)
|
|
fi
|
|
# return the answer
|
|
echo "${answer:-$folder}"
|
|
}
|
|
|
|
# select multiple directories from one directory
|
|
function getSelectedDirectories() {
|
|
# the selected folder
|
|
local answer
|
|
# set the local path
|
|
local path="${2:-}"
|
|
# we start the selection array
|
|
local selected=()
|
|
# our counter
|
|
local i=0
|
|
# whiptail box size details
|
|
local description_lines
|
|
local height
|
|
# now check if this dir has sub dirs
|
|
if hasDirectories '' "$path"; then
|
|
# loop over the directory
|
|
for dir_ in "${path%/}/"*; do
|
|
# remove the full path
|
|
dir_="${dir_/$path/}"
|
|
# load the selection
|
|
selected+=("${dir_#/}" "${dir_#/}" "OFF")
|
|
# increment our pointer
|
|
if [ "$i" -le 10 ]; then
|
|
i=$((i + 1))
|
|
fi
|
|
done
|
|
|
|
# Calculate the height based on the description length and directory count
|
|
description_lines=$(echo -e "${1}" | wc -l)
|
|
height=$((description_lines + i + 7))
|
|
|
|
# now make the selection
|
|
answer=$(whiptail --title "${3:-Make a Selection}" --checklist\
|
|
"${1}" $height 112 $i \
|
|
"${selected[@]}" --backtitle "${BACK_TITLE}" --nocancel --notags 3>&1 1>&2 2>&3)
|
|
# return the answer
|
|
echo "${answer[@]}"
|
|
else
|
|
echo ''
|
|
fi
|
|
}
|
|
|
|
# create a yml new line with 3 indents
|
|
function getYMLine3() {
|
|
# return line
|
|
cat <<EOF
|
|
|
|
${1}
|
|
EOF
|
|
}
|
|
|
|
# create a yml new line with 2 indents
|
|
function getYMLine2() {
|
|
# return line
|
|
cat <<EOF
|
|
|
|
${1}
|
|
EOF
|
|
}
|
|
|
|
# create a yml new line with 1 indent
|
|
function getYMLine1() {
|
|
# return line
|
|
cat <<EOF
|
|
|
|
${1}
|
|
EOF
|
|
}
|
|
|
|
# get input from user
|
|
function getPassword() {
|
|
# set local var
|
|
local PASSWORD
|
|
# get the pass
|
|
PASSWORD=$(whiptail --passwordbox "$1" 10 112 "${2:-}" --title "${3:-Get Password}" \
|
|
--backtitle "${BACK_TITLE}"--nocancel 3>&1 1>&2 2>&3)
|
|
# return the password
|
|
echo "${PASSWORD}"
|
|
}
|
|
|
|
# get the target branch to use in update
|
|
function getTargetBranch() {
|
|
# now make the selection
|
|
answer=$(whiptail --title "Select Update Channel" \
|
|
--radiolist --backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"You can select the update channel you would like to use." 10 80 2 \
|
|
"master" "Stable Version" "ON" \
|
|
"staging" "Developer Version" "OFF" \
|
|
3>&1 1>&2 2>&3)
|
|
# return the answer (default master)
|
|
echo "${answer:-master}"
|
|
}
|
|
|
|
# get the target repository to use in update
|
|
function getImageSource() {
|
|
# we set some local stuff
|
|
local image
|
|
local image_source
|
|
local images_source
|
|
local default
|
|
local default_octojoom
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=2
|
|
# set the defaults
|
|
default="joomla|https://hub.docker.com/_/joomla?tab=tags;https://raw.githubusercontent.com/joomla-docker/docker-joomla/master/docker-entrypoint.sh"
|
|
default_octojoom="llewellyn/joomla|https://hub.docker.com/r/llewellyn/joomla/tags;https://git.vdm.dev/octoleo/docker-joomla/raw/branch/octoleo/docker-entrypoint.sh"
|
|
# we only ask if we are in expert mode
|
|
if isExpert; then
|
|
# set the base images source
|
|
menu_options+=("${default}" "Joomla official image" "OFF")
|
|
menu_options+=("${default_octojoom}" "Octoleo Joomla image" "OFF")
|
|
# get existing source
|
|
if [ -f "${VDM_SRC_PATH}/.images-source" ] && readarray -t images_source <"${VDM_SRC_PATH}/.images-source"; then
|
|
# build the menus
|
|
if [ "${#images_source[@]}" -gt 0 ]; then
|
|
# loop source images
|
|
for image in "${images_source[@]}"; do
|
|
# the image name (get before first comma)
|
|
image_name="${image%%,*}"
|
|
# the image description (get after last comma)
|
|
image_desc="${image##*,}"
|
|
# make sure we have a value, and it is not the defaults already set
|
|
if [ "${#image_name}" -ge 1 ] && [ "${#image_desc}" -ge 1 ] &&
|
|
[ "${image_name}" != "${default}" ] && [ "${image_name}" != "${default_octojoom}" ]; then
|
|
# load the source name and description
|
|
menu_options+=("${image_name}" "${image_desc}" "OFF")
|
|
# increment our counter
|
|
i=$((i + 1))
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
# now make the selection
|
|
image_source=$(whiptail --title "Select image source repository" \
|
|
--radiolist --backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"You can select the source of your Joomla! image." 10 80 $i \
|
|
"${menu_options[@]}" 3>&1 1>&2 2>&3)
|
|
fi
|
|
# return the answer (default joomla)
|
|
echo "${image_source:-$default}"
|
|
}
|
|
|
|
# get a list of domains locally set
|
|
function getListDomains() {
|
|
# get the separator
|
|
local separator="${1}"
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
local domains
|
|
# get existing domains
|
|
if [ -f "${VDM_SRC_PATH}/.domains" ] && readarray -t domains <"${VDM_SRC_PATH}/.domains"; then
|
|
# check that we have values
|
|
if [ "${#domains[@]}" -gt 0 ]; then
|
|
# build the menu
|
|
for domain in "${domains[@]}"; do
|
|
# load the back menu
|
|
[ "${#domain}" -ge 1 ] && menu_options+=("${domain}")
|
|
done
|
|
# we show a list of options including the option to add another
|
|
# shellcheck disable=SC2005
|
|
echo "$(printf "${separator}%s" "${menu_options[@]}")"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# to set a global multiple domains file and values
|
|
function getMultiDomain() {
|
|
# we set some local stuff
|
|
local domain_name
|
|
local domains
|
|
# menu for dynamic addition
|
|
local menu_options=()
|
|
# our counter
|
|
local i=0
|
|
# always add the main domain or (default) first
|
|
# so we should always have a selection
|
|
saveMultiDomain "${VDM_DOMAIN}"
|
|
# now clear the main domain (in case we use getDomain)
|
|
unset VDM_DOMAIN
|
|
# get existing domains
|
|
if [ -f "${VDM_SRC_PATH}/.domains" ] && readarray -t domains <"${VDM_SRC_PATH}/.domains"; then
|
|
# build the menu
|
|
if [ "${#domains[@]}" -gt 0 ]; then
|
|
# loop domains
|
|
for domain in "${domains[@]}"; do
|
|
# load the domain if it has a length
|
|
[ "${#domain}" -ge 1 ] && menu_options+=("${domain}" "${domain}" "OFF")
|
|
# increment our counter
|
|
[ "${#domain}" -ge 1 ] && i=$((i + 1))
|
|
done
|
|
# make sure we have domains
|
|
if [ "${#menu_options[@]}" -gt 0 ]; then
|
|
# we show a list of options including the option to add another
|
|
domain_name=$(whiptail --title "Select a Domain" \
|
|
--radiolist --backtitle "${BACK_TITLE}" --nocancel --notags \
|
|
"Select a domain, or none to add another." 30 80 $i \
|
|
"${menu_options[@]}" 3>&1 1>&2 2>&3)
|
|
fi
|
|
fi
|
|
fi
|
|
# check if we have a selection
|
|
if [ "${domain_name:-none}" = 'none' ]; then
|
|
# we must let them enter the new domain name
|
|
getDomain 'Enter a domain name' 'Enter a Domain Name'
|
|
else
|
|
# set the new main domain
|
|
VDM_DOMAIN="${domain_name}"
|
|
# update the main domain
|
|
export VDM_DOMAIN
|
|
fi
|
|
# add for next time
|
|
saveMultiDomain "${VDM_DOMAIN}"
|
|
}
|
|
|
|
# set the VDM domain value
|
|
function getDomain() {
|
|
# set some locals
|
|
local message="Enter main domain name"
|
|
local title="Enter Main Domain"
|
|
local tld="${VDM_CONTAINER_TYPE:-vdm}"
|
|
# get the arg passed if any
|
|
message="${1:-$message}"
|
|
title="${2:-$title}"
|
|
# get the VDM Domain value if not already set
|
|
while [ ${#VDM_DOMAIN} -le 1 ] || [[ "${VDM_DOMAIN}" != *.* ]]; do
|
|
# get the value
|
|
VDM_DOMAIN=$(getInput "${message}\n[must have at least one dot]" \
|
|
"${USER:-octoleo}.${tld,,}" "${title}")
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_DOMAIN} -le 1 ]; then
|
|
showError "You must enter a domain name!"
|
|
elif [[ "${VDM_DOMAIN}" != *.* ]]; then
|
|
showError "You must enter a domain name with at least one dot"
|
|
fi
|
|
done
|
|
# update the main domain
|
|
export VDM_DOMAIN
|
|
}
|
|
|
|
# set the main domain
|
|
function getMainDomain() {
|
|
# we first check if we have a main domain passed as command argument
|
|
if $VDM_ARG_DOMAIN; then
|
|
# if domain passed by arg we just return it
|
|
getDomain 'Enter a domain name' 'Enter a Domain Name'
|
|
else
|
|
# update the main domain with a selection
|
|
getMultiDomain
|
|
fi
|
|
}
|
|
|
|
# set the container user
|
|
function setContainerUser() {
|
|
# ask if a new User ID should be set if one is set
|
|
if [ -n "${VDM_PUID}" ] && [[ "${VDM_PUID}" =~ ^[0-9]+$ ]] &&
|
|
(whiptail --yesno "The user ID in ${PROGRAM_NAME} memory is ${VDM_PUID}, would you like to change this user ID?" \
|
|
--defaultno --title "Set User ID" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# always first reset
|
|
unset VDM_PUID
|
|
fi
|
|
# give little notice
|
|
# showNotice "To get the ID of a user in a container:\n\n$ docker exec -it container_name /bin/bash\n$ id -u www-data"
|
|
# we first get the container user ID
|
|
while [ -z "${VDM_PUID}" ] || [ ${#VDM_PUID} -le 1 ] || ! [[ "${VDM_PUID}" =~ ^[0-9]+$ ]]; do
|
|
VDM_PUID=$(getInput "Enter user ID for the ${VDM_CONTAINER_TYPE^} container. Use default:${1:-1000} if you don't know.\n[add only a number]" \
|
|
"${1:-1000}" 'Enter User ID')
|
|
# check if we have success
|
|
if [ ${#VDM_PUID} -le 1 ] || ! [[ "${VDM_PUID}" =~ ^[0-9]+$ ]]; then
|
|
showError "You must enter a user ID like: ${1:-1000} (only the number)"
|
|
fi
|
|
done
|
|
# ask if a new Group ID should be set if one is set
|
|
if [ -n "${VDM_PGID}" ] && [[ "${VDM_PGID}" =~ ^[0-9]+$ ]] &&
|
|
(whiptail --yesno "The user-group ID in ${PROGRAM_NAME} memory is ${VDM_PGID}, would you like to change this user-group ID?" \
|
|
--defaultno --title "Set User-Group ID" --backtitle "${BACK_TITLE}"8 112); then
|
|
# always first reset
|
|
unset VDM_PGID
|
|
fi
|
|
# give little notice
|
|
# showNotice "To get the ID of a user-group in a container:\n\n$ docker exec -it container_name /bin/bash\n$ id -u www-data"
|
|
# we get the container user-group ID
|
|
while [ -z "${VDM_PGID}" ] || [ ${#VDM_PGID} -le 1 ] || ! [[ "${VDM_PGID}" =~ ^[0-9]+$ ]]; do
|
|
VDM_PGID=$(getInput "Enter user-group ID for the ${VDM_CONTAINER_TYPE^} container. Use default:${1:-1000} if you don't know.\n[add only a number]" \
|
|
"${1:-1000}" 'Enter User Group ID')
|
|
# check if we have success
|
|
if [ ${#VDM_PGID} -le 1 ] || ! [[ "${VDM_PGID}" =~ ^[0-9]+$ ]]; then
|
|
showError "You must enter a user-group ID like: ${1:-1000} (only the number)"
|
|
fi
|
|
done
|
|
# make available
|
|
export VDM_PUID
|
|
export VDM_PGID
|
|
}
|
|
|
|
# Set the program mode
|
|
function setMode() {
|
|
# Local variable to store the mode
|
|
local mode="${1:-basic}"
|
|
# Local variable to store the VDM_EXPERT_MODE value
|
|
local vdm_expert_mode="false"
|
|
|
|
# Set the VDM_EXPERT_MODE value based on the mode
|
|
case "$mode" in
|
|
basic)
|
|
vdm_expert_mode="false"
|
|
;;
|
|
expert)
|
|
vdm_expert_mode="true"
|
|
;;
|
|
*)
|
|
echo "Error: Unsupported mode. Use 'basic' or 'expert'."
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
# Set persistent
|
|
setUniqueEnvVariable "VDM_EXPERT_MODE=${vdm_expert_mode}"
|
|
|
|
# Make global
|
|
export VDM_EXPERT_MODE="$vdm_expert_mode"
|
|
}
|
|
|
|
# set the domain
|
|
function setDomain() {
|
|
# allow multi domain setup
|
|
if allowMultiDomains; then
|
|
# select a domain name
|
|
getMainDomain
|
|
else
|
|
# set the main domain if not set
|
|
setMainDomain
|
|
fi
|
|
}
|
|
|
|
# set the main domain
|
|
function setMainDomain() {
|
|
# set the main domain if not set
|
|
getDomain
|
|
# add this value if not set variable
|
|
setUniqueEnvVariable "VDM_DOMAIN=\"${VDM_DOMAIN}\""
|
|
}
|
|
|
|
# set the sub domain
|
|
function setSubDomain() {
|
|
# make sure it has not been used before,
|
|
# also make sure its not a port or a ....db
|
|
while [ ${#VDM_SUBDOMAIN} -le 1 ] || [[ "${VDM_SUBDOMAIN}" =~ [^a-zA-Z] ]] ||
|
|
[ -d "${VDM_REPO_PATH}/${3:-$VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}" ] ||
|
|
[ -d "${VDM_REPO_PATH}/${3:-$VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN%db}.${VDM_DOMAIN}" ] ||
|
|
[ "${VDM_SUBDOMAIN}" = "${2}" ]; do
|
|
# get the value
|
|
VDM_SUBDOMAIN=$(getInput "Enter sub-domain used for this ${VDM_CONTAINER_TYPE^} container.\n[Text with no spaces that is only alphabetical]" \
|
|
"${1}" 'Enter Sub-Domain')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_SUBDOMAIN} -ge 1 ] && [ -d "${VDM_REPO_PATH}/${3:-$VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN}.${VDM_DOMAIN}" ] ||
|
|
[ -d "${VDM_REPO_PATH}/${3:-$VDM_CONTAINER_TYPE}/available/${VDM_SUBDOMAIN%db}.${VDM_DOMAIN}" ]; then
|
|
showError "The sub-domain:${VDM_SUBDOMAIN} is already used. Select another"
|
|
elif [[ "${VDM_SUBDOMAIN}" =~ [^a-zA-Z] ]]; then
|
|
showError "You must enter a sub-domain that is only alphabetical!"
|
|
elif [ ${#VDM_SUBDOMAIN} -le 1 ]; then
|
|
showError "You must enter a sub-domain!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_SUBDOMAIN
|
|
}
|
|
|
|
# to set a global multiple domains file and values
|
|
function setMultiDomains() {
|
|
# set some locals
|
|
local domain_name
|
|
local list_domains
|
|
local question
|
|
# allow multi domain setup
|
|
if allowMultiDomains; then
|
|
# get the list of domains
|
|
list_domains=$(getListDomains "\n")
|
|
# the question based on current state
|
|
[ -f "${VDM_SRC_PATH}/.domains" ] && question="Would you like to add another domain to ${PROGRAM_NAME}?\nThese Domains already set:\n${list_domains}" ||
|
|
question="Would you like to add a domain to ${PROGRAM_NAME}?"
|
|
# get the key if not set
|
|
while (whiptail --yesno "${question}" --scrolltext --defaultno \
|
|
--title "Add Domain" --backtitle "${BACK_TITLE}" 20 112); do
|
|
# now clear the main domain each time
|
|
unset VDM_DOMAIN
|
|
# we must let them enter the new domain name
|
|
getDomain 'Enter a domain name' 'Enter a Domain Name'
|
|
# add for next time
|
|
saveMultiDomain "${VDM_DOMAIN}"
|
|
# get the list of domains
|
|
list_domains=$(getListDomains "\n")
|
|
# update the question
|
|
question="Would you like to add another domain to ${PROGRAM_NAME}?\nThese Domains already set:\n${list_domains}"
|
|
done
|
|
fi
|
|
}
|
|
|
|
# set the multi domain switch
|
|
function setMultiDomainSwitch() {
|
|
# Allow multiple domains
|
|
if [ "${VDM_MULTI_DOMAIN:-not}" = 'not' ]; then
|
|
# explain the pros and cons...
|
|
showNotice "Next you should make the selection of using a single or multiple domain setup.\n\n\
|
|
With multiple domain setups you will need to select a main domain each time you setup a new container.\n\
|
|
With a single domain setup you setup the main domain once, and then only need setup the subdomains\n\
|
|
with each new container."
|
|
# check the security switch
|
|
if (whiptail --yesno "Would you like to use a multiple domains setup?" \
|
|
--defaultno --title "Allow Multi Domains" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the secure switch
|
|
VDM_MULTI_DOMAIN=true
|
|
else
|
|
VDM_MULTI_DOMAIN=false
|
|
fi
|
|
fi
|
|
# add this value if not set variable
|
|
setEnvVariable "VDM_MULTI_DOMAIN=${VDM_MULTI_DOMAIN}"
|
|
# make sure it is available
|
|
export VDM_MULTI_DOMAIN
|
|
}
|
|
|
|
# set the unique key
|
|
function setUniqueKey() {
|
|
# get the key if not set
|
|
while [ ${#VDM_KEY} -le 1 ] || [ -d "${VDM_PROJECT_PATH}/${VDM_KEY}" ] || [[ "${VDM_KEY}" =~ [^a-zA-Z] ]]; do
|
|
# get the value
|
|
VDM_KEY=$(getInput "${1:-Enter key used for container naming and name of the persistent volume folder.}\n[Text with no spaces that is only alphabetical]" \
|
|
'' 'Enter Key')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_KEY} -ge 1 ] && [ -d "${VDM_PROJECT_PATH}/${VDM_KEY}" ]; then
|
|
showError "The key:${VDM_KEY} is already used. Select another"
|
|
elif [[ "${VDM_KEY}" =~ [^a-zA-Z] ]]; then
|
|
showError "You must enter a key with no spaces that is only alphabetical!"
|
|
elif [ ${#VDM_KEY} -le 1 ]; then
|
|
showError "You must enter a key!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_KEY
|
|
}
|
|
|
|
# set the Joomla website details
|
|
function setJoomlaWebsiteDetails() {
|
|
# ask if we should add mailcatcher
|
|
if (whiptail --yesno "Would you like to enable website autodeploy for ${VDM_CONTAINER_TYPE,}:${VDM_JV}" \
|
|
--defaultno --title "Enable Autodeploy" --backtitle "${BACK_TITLE}" 8 112); then
|
|
|
|
# ask for website name
|
|
setJoomlaSiteName
|
|
|
|
# ask for username
|
|
setJoomlaUsername
|
|
|
|
# ask for user
|
|
setJoomlaUser
|
|
|
|
# ask for email
|
|
setJoomlaEmail
|
|
|
|
# ask for username password
|
|
setJoomlaPassword
|
|
|
|
fi
|
|
}
|
|
|
|
# set the website name
|
|
function setJoomlaSiteName() {
|
|
# get the key if not set
|
|
while [ ${#VDM_J_SITE_NAME} -le 2 ]; do
|
|
# get the value
|
|
VDM_J_SITE_NAME=$(getInput "Enter a Joomla website name." \
|
|
'Joomla! CMS' 'Enter Site Name')
|
|
# keep asking if empty
|
|
if [ ${#VDM_J_SITE_NAME} -le 2 ]; then
|
|
showError "You must enter a site name longer than 2 characters!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_J_SITE_NAME
|
|
}
|
|
|
|
# set the username
|
|
function setJoomlaUsername() {
|
|
# get the key if not set
|
|
while [ ${#VDM_J_USERNAME} -le 1 ] || [[ "${VDM_J_USERNAME}" =~ [^a-zA-Z] ]]; do
|
|
# get the value
|
|
VDM_J_USERNAME=$(getInput "Enter a Joomla username.\n[Text with no spaces that is only alphabetical]" \
|
|
'user' 'Enter Username')
|
|
# keep asking if empty
|
|
if [[ "${VDM_J_USERNAME}" =~ [^a-zA-Z] ]]; then
|
|
showError "You must enter a username with no spaces that is only alphabetical!"
|
|
elif [ ${#VDM_J_USERNAME} -le 1 ]; then
|
|
showError "You must enter a username!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_J_USERNAME
|
|
}
|
|
|
|
# set the user
|
|
function setJoomlaUser() {
|
|
# get the key if not set
|
|
while [ ${#VDM_J_USER} -le 2 ]; do
|
|
# get the value
|
|
VDM_J_USER=$(getInput "Enter a Joomla user." \
|
|
'John Doe' 'Enter User Name')
|
|
# keep asking if empty
|
|
if [ ${#VDM_J_USER} -le 2 ]; then
|
|
showError "You must enter a user!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_J_USER
|
|
}
|
|
|
|
# set the email
|
|
function setJoomlaEmail() {
|
|
# Email regex for basic validation
|
|
local email_regex="^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
|
|
|
|
# Keep prompting until a valid email is provided
|
|
while [[ ! "${VDM_J_EMAIL}" =~ $email_regex ]]; do
|
|
# Get the email
|
|
VDM_J_EMAIL=$(getInput "Enter a Joomla email address." \
|
|
'admin@example.org' 'Enter Email')
|
|
|
|
# Check if the input matches the basic email regex pattern
|
|
if [[ ! "${VDM_J_EMAIL}" =~ $email_regex ]]; then
|
|
showError "You must enter a valid email address!"
|
|
fi
|
|
done
|
|
|
|
# Export the variable to make it available for child processes
|
|
export VDM_J_EMAIL
|
|
}
|
|
|
|
# set the username
|
|
function setJoomlaPassword() {
|
|
# get the key if not set
|
|
while [ ${#VDM_J_PASSWORD} -le 12 ]; do
|
|
# get the value
|
|
VDM_J_PASSWORD=$(getInput "Enter Joomla User Password" \
|
|
'joomla-17082005' 'Enter Joomla User Password')
|
|
# keep asking if empty
|
|
if [ ${#VDM_J_PASSWORD} -le 12 ]; then
|
|
showError "You must enter a password with more than 4 characters!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_J_PASSWORD
|
|
}
|
|
|
|
# set the number of containers to build
|
|
function setNumberContainers() {
|
|
local valid=0
|
|
while [ "$valid" -eq 0 ]; do
|
|
# get the value
|
|
VDM_NUMBER_CONTAINERS=$(getInput "Enter the number of containers you would like to deploy.\n[Just a number!]" \
|
|
10 'Enter Number')
|
|
# check that the number is above 1 and below 100
|
|
if ! [[ $VDM_NUMBER_CONTAINERS =~ ^[0-9]+$ ]]; then
|
|
showError "You must enter a number!"
|
|
elif [[ $VDM_NUMBER_CONTAINERS -le 1 ]]; then
|
|
showError "The number (${VDM_NUMBER_CONTAINERS}) must be above 1"
|
|
elif [[ $VDM_NUMBER_CONTAINERS -ge 100 ]]; then
|
|
showError "The number (${VDM_NUMBER_CONTAINERS}) must be below 100"
|
|
else
|
|
valid=1
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_NUMBER_CONTAINERS
|
|
}
|
|
|
|
# set the Environment key
|
|
function setEnvironmentKey() {
|
|
# get the env key if not set
|
|
while [ ${#VDM_ENV_KEY} -le 1 ] || [[ "${VDM_ENV_KEY}" =~ [^a-zA-Z] ]]; do
|
|
# get the value
|
|
VDM_ENV_KEY=$(getInput "Enter environment key used to load the container environment variables.\n[Text with no spaces that is only alphabetical UPPERCASE]" \
|
|
"${VDM_KEY^^}" 'Enter ENV Key')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_ENV_KEY} -le 1 ]; then
|
|
showError "You must enter an environment key!"
|
|
elif [[ "${VDM_ENV_KEY}" =~ [^a-zA-Z] ]]; then
|
|
showError "You must enter an environment key with no spaces that is only alphabetical!"
|
|
fi
|
|
done
|
|
# make sure it is available
|
|
export VDM_ENV_KEY
|
|
}
|
|
|
|
# set the update of host files
|
|
function setUpdateHostFile() {
|
|
# check if we have secure switch set
|
|
if [ "${VDM_UPDATE_HOST:-not}" = 'not' ]; then
|
|
# check the security switch
|
|
if (whiptail --yesno "Would you like to update your host file with each new domain you add?" \
|
|
--defaultno --title "Update /etc/hosts" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the secure switch
|
|
VDM_UPDATE_HOST=true
|
|
else
|
|
VDM_UPDATE_HOST=false
|
|
fi
|
|
fi
|
|
# add this value since its not set variable
|
|
setEnvVariable "VDM_UPDATE_HOST=${VDM_UPDATE_HOST}"
|
|
# make sure it is available
|
|
export VDM_UPDATE_HOST
|
|
}
|
|
|
|
# set the image source values
|
|
function setImageSource() {
|
|
# some local values
|
|
local vdm_image_source
|
|
local vdm_tag_url
|
|
# get the Joomla version if not set
|
|
while [ -z "${VDM_J_REPO}" ] || [ ${#VDM_J_REPO} -le 3 ]; do
|
|
# get the image source
|
|
vdm_image_source=$(getImageSource)
|
|
# build the source key (string before the first | )
|
|
VDM_J_REPO="${vdm_image_source%%|*}"
|
|
# set the source entry-point (url after the last ; )
|
|
VDM_ENTRY_REPO="${vdm_image_source##*;}"
|
|
# remove the J_REPO (remove everything before the first | )
|
|
vdm_image_source="${vdm_image_source##*|}"
|
|
# set the source entry-point (string before the first ; )
|
|
vdm_tag_url="${vdm_image_source%%;*}"
|
|
# keep asking
|
|
[ ${#VDM_J_REPO} -le 3 ] && {
|
|
showError "Seems like the source selected is not correctly configured, please select another."
|
|
}
|
|
# make sure the source is set
|
|
[[ "${VDM_ENTRY_REPO}" == *'docker-entrypoint.sh' ]] || {
|
|
VDM_J_REPO=''
|
|
showError "Seems like the source selected is not correctly configured, please select another."
|
|
}
|
|
done
|
|
# get the Joomla version if not set
|
|
while [ ${#VDM_JV} -le 1 ]; do
|
|
# get the value
|
|
VDM_JV=$(getInput "Enter Joomla version tag for this container.\n[See available tags here ${vdm_tag_url}]" '5.0' 'Enter Version Tag')
|
|
# keep asking
|
|
[ ${#VDM_JV} -ge 1 ] || {
|
|
showError "You must enter a version tag. See available tags here ${vdm_tag_url}"
|
|
}
|
|
done
|
|
# make the value available globally
|
|
export VDM_ENTRY_REPO
|
|
export VDM_J_REPO
|
|
export VDM_JV
|
|
}
|
|
|
|
# check version
|
|
function isVersionAbove() {
|
|
local tag="$1"
|
|
local target_version="$2"
|
|
local tag_major
|
|
local tag_minor
|
|
local target_major
|
|
local target_minor
|
|
|
|
# Extract major and minor versions for the tag and the target_version
|
|
tag_major=$(echo "$tag" | awk -F'[.-]' '{print $1}')
|
|
tag_minor=$(echo "$tag" | awk -F'[.-]' '{print $2}')
|
|
target_major=$(echo "$target_version" | awk -F'.' '{print $1}')
|
|
target_minor=$(echo "$target_version" | awk -F'.' '{print $2}')
|
|
|
|
# Compare major versions
|
|
if [[ "$tag_major" -gt "$target_major" ]]; then
|
|
return 0
|
|
elif [[ "$tag_major" -eq "$target_major" && "$tag_minor" -ge "$target_minor" ]]; then
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
# set persistence volumes
|
|
function setPersistence() {
|
|
# ask the question
|
|
if (whiptail --yesno "Would you like to enable persistence on this $1." \
|
|
--title "Persist Volume" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# yes persistence
|
|
return 0
|
|
fi
|
|
# no persistence
|
|
return 1
|
|
}
|
|
|
|
# set the PHP settings
|
|
function setPHPSettings() {
|
|
# ask the question
|
|
if (whiptail --yesno "Would you like to set some PHP overrides for the Joomla container.\n\nTo make these changes we need sudo privileges." \
|
|
--defaultno --title "PHP.ini values" --backtitle "${BACK_TITLE}" 9 112); then
|
|
|
|
# max_execution_time
|
|
VDM_max_execution_time=$(getInputNow "Enter max execution time" \
|
|
"${VDM_max_execution_time:-124}" 'max_execution_time')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_max_execution_time=${VDM_max_execution_time}"
|
|
|
|
# max_input_time
|
|
VDM_max_input_time=$(getInputNow "Enter max input time" \
|
|
"${VDM_max_input_time:-1500}" 'max_input_time')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_max_input_time=${VDM_max_input_time}"
|
|
|
|
# max_input_vars
|
|
VDM_max_input_vars=$(getInputNow "Enter max_input_vars" \
|
|
"${VDM_max_input_vars:-3000}" 'max_input_vars')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_max_input_vars=${VDM_max_input_vars}"
|
|
|
|
# error_reporting
|
|
default_error_reporting="E_ALL & ~E_DEPRECATED & ~E_STRICT"
|
|
VDM_error_reporting=$(getInputNow "Enter error reporting" \
|
|
"${VDM_error_reporting:-$default_error_reporting}" 'error_reporting')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_error_reporting=\"${VDM_error_reporting}\""
|
|
|
|
# upload_max_filesize
|
|
VDM_upload_max_filesize=$(getInputNow "Enter upload max filesize" \
|
|
"${VDM_upload_max_filesize:-256M}" 'upload_max_filesize')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_upload_max_filesize=\"${VDM_upload_max_filesize}\""
|
|
|
|
# post_max_size
|
|
VDM_post_max_size=$(getInputNow "Enter post max size" \
|
|
"${VDM_post_max_size:-256M}" 'post_max_size')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_post_max_size=\"${VDM_post_max_size}\""
|
|
|
|
# memory_limit
|
|
VDM_memory_limit=$(getInputNow "Enter memory limit" \
|
|
"${VDM_memory_limit:-256M}" 'memory_limit')
|
|
# remember this for next time
|
|
setUniqueEnvVariable "VDM_memory_limit=\"${VDM_memory_limit}\""
|
|
|
|
# make sure the directory exist
|
|
mkdir -p "${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}"
|
|
|
|
# push all these values to the php.ini file
|
|
{
|
|
echo "max_execution_time = ${VDM_max_execution_time}"
|
|
echo "max_input_time = ${VDM_max_input_time}"
|
|
echo "max_input_vars = ${VDM_max_input_vars}"
|
|
echo "error_reporting = ${VDM_error_reporting}"
|
|
echo "upload_max_filesize = ${VDM_upload_max_filesize}"
|
|
echo "post_max_size = ${VDM_post_max_size}"
|
|
echo "memory_limit = ${VDM_memory_limit}"
|
|
} > "${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini"
|
|
|
|
# allow custom edit
|
|
if isExpert && (whiptail --yesno "Would you like to set some more custom PHP overrides for this Joomla container" \
|
|
--defaultno --title "Edit PHP.ini" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# give little heads-up
|
|
showNotice "${USER^}, to save the changes you've made or to just close the file again press:\n\n[ctrl+x] with nano on ubuntu." 13
|
|
# lets open the file with nano for now
|
|
sudo "${EDITOR:-nano}" "${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini"
|
|
fi
|
|
|
|
# set the ownership
|
|
if [ -n "${VDM_PUID}" ] && [ -n "${VDM_PGID}" ]; then
|
|
sudo chown "${VDM_PUID}":"${VDM_PGID}" "${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini"
|
|
else
|
|
sudo chown www-data:www-data "${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini"
|
|
fi
|
|
# make sure the permission are good
|
|
sudo chmod 600 "${VDM_PROJECT_PATH}/${VDM_PHP_PROJECT_PATH}/php.ini"
|
|
|
|
# yes load php.ini volume to the container
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
# set the docker entrypoint
|
|
function setDockerEntrypoint() {
|
|
# ask the question
|
|
if (whiptail --yesno "Would you like to customize the entrypoint script for this Joomla container" \
|
|
--defaultno --title "entrypoint.sh values" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# make sure the directory exist
|
|
mkdir -p "${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}"
|
|
# unattended deploy
|
|
# if (whiptail --yesno "Would you like to to setup unattended deployment for this Joomla container" --defaultno --title "Unattended Deployment" 8 112); then
|
|
# echo "soon we will have this ready"
|
|
# fi
|
|
# download entrypoint.sh file to the project folder
|
|
if sudo curl --fail -L "${VDM_ENTRY_REPO}" -o "${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}/entrypoint.sh" 2>/dev/null; then
|
|
# give little heads-up
|
|
showNotice "${USER^}, to save the changes you've made or to just close the file again press:\n\n[ctrl+x] with nano on ubuntu." 13
|
|
# lets open the file with nano for now
|
|
sudo "${EDITOR:-nano}" "${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}/entrypoint.sh"
|
|
|
|
# set the ownership
|
|
sudo chown root:root "${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}/entrypoint.sh"
|
|
# make sure the permission are good
|
|
sudo chmod +x "${VDM_PROJECT_PATH}/${VDM_ENTRY_PROJECT_PATH}/entrypoint.sh"
|
|
|
|
# we have the file set
|
|
return 0
|
|
else
|
|
# show the error
|
|
showError "The entrypoint.sh could not be set."
|
|
fi
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
# set the secure state
|
|
function setSecureCloudflareState() {
|
|
# check the security switch
|
|
if (whiptail --yesno "Will this container be proxied by Cloudflare [ONLY for server proxied in none-strict mode via Cloudflare]" \
|
|
--defaultno --title "Cloudflare" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the secure switch
|
|
VDM_SECURE_CLOUDFLARE=true
|
|
else
|
|
VDM_SECURE_CLOUDFLARE=false
|
|
fi
|
|
# make sure it is available
|
|
export VDM_SECURE_CLOUDFLARE
|
|
}
|
|
|
|
# set the secure state
|
|
function setSecureState() {
|
|
if [ "${VDM_SECURE:-not}" = 'not' ]; then
|
|
# check the security switch
|
|
if (whiptail --yesno "Would you like to use Letsencrypt auto setup for your containers [ONLY for server with public static IP]" \
|
|
--defaultno --title "Letsencrypt" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# we set the secure switch
|
|
VDM_SECURE=true
|
|
else
|
|
VDM_SECURE=false
|
|
fi
|
|
fi
|
|
# add this value if not set variable
|
|
setEnvVariable "VDM_SECURE=${VDM_SECURE}"
|
|
# make sure it is available
|
|
export VDM_SECURE
|
|
}
|
|
|
|
# Create Docker networks if they do not exist
|
|
function setNetworks() {
|
|
# Default network names and subnets
|
|
local traefik_gateway="${VDM_TRAEFIK_GATEWAY:-traefik_webgateway}"
|
|
local traefik_subnet="${VDM_TRAEFIK_SUBNET:-172.22.0.0/24}"
|
|
local openssh_gateway="${VDM_OPENSSH_GATEWAY:-openssh_gateway}"
|
|
local openssh_subnet="${VDM_OPENSSH_SUBNET:-172.23.0.0/24}"
|
|
|
|
# Create traefik network if it does not exist
|
|
docker network inspect "${traefik_gateway}" >/dev/null 2>&1 ||
|
|
docker network create "${traefik_gateway}" --subnet "${traefik_subnet}"
|
|
|
|
# Create openssh network if it does not exist
|
|
docker network inspect "${openssh_gateway}" >/dev/null 2>&1 ||
|
|
docker network create "${openssh_gateway}" --subnet "${openssh_subnet}"
|
|
}
|
|
|
|
# to set a global Env Variable
|
|
function setUniqueEnvVariable() {
|
|
# some locals
|
|
local environment_variable="$1"
|
|
# always remove previous environment variable
|
|
deleteEnvVariable "${environment_variable%%=*}"
|
|
# set the new environment variable
|
|
setEnvVariable "${environment_variable}" && return 0
|
|
# or failed
|
|
return 12
|
|
}
|
|
|
|
# to set a global Env Variable
|
|
function setEnvVariable() {
|
|
# check if the env file exist
|
|
if [ -f "${VDM_SRC_PATH}/.env" ]; then
|
|
grep -q "${1}" "${VDM_SRC_PATH}/.env" || echo "${1}" >>"${VDM_SRC_PATH}/.env"
|
|
elif (whiptail --yesno "Can we create the ${VDM_SRC_PATH}/.env file" \
|
|
--title "Environment Variable File" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# make sure the folder exist
|
|
mkdir -p "${VDM_SRC_PATH}"
|
|
# so we creat the file
|
|
echo "${1}" >"${VDM_SRC_PATH}/.env"
|
|
# make sure the permissions are secured
|
|
chmod 600 "${VDM_SRC_PATH}/.env"
|
|
else
|
|
showError "The ${VDM_SRC_PATH}/.env file does not exist. So ${1} could not be added!"
|
|
# we return false
|
|
return 12
|
|
fi
|
|
# we return true
|
|
return 0
|
|
}
|
|
|
|
# to set a container Env Variable
|
|
function setContainerEnvVariable() {
|
|
# check if the env file exist
|
|
if [ -f "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" ]; then
|
|
grep -q "${1}" "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env" || echo "${1}" >>"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
elif (whiptail --yesno "Can we create the ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env file" \
|
|
--title "Container Environment Variable File" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# make sure the folder exist
|
|
mkdir -p "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}"
|
|
# so we creat the file
|
|
echo "${1}" >"${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
# make sure the permissions are secured
|
|
chmod 600 "${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env"
|
|
else
|
|
showError "The ${VDM_REPO_PATH}/${VDM_CONTAINER_TYPE}/.env file does not exist. So ${1} could not be added!"
|
|
# we return false
|
|
return 12
|
|
fi
|
|
# we return true
|
|
return 0
|
|
}
|
|
|
|
# check if a Directory exist and if it has sub-directories
|
|
function hasDirectories() {
|
|
# shellcheck disable=SC2046
|
|
# shellcheck disable=SC2012
|
|
if [ -d "${2:-$VDM_REPO_PATH}/${1:-}" ] && [ $(ls -A "${2:-$VDM_REPO_PATH}/${1:-}" | wc -l) -ne 0 ]; then
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
# take down apache
|
|
function downApache() {
|
|
# make sure port 80 is not used by apache
|
|
command -v apache2 >/dev/null 2>&1 && [[ $(service apache2 status) == *"active (running)"* ]] && {
|
|
if (whiptail --yesno "Traefik needs port 80/443 and since Apache is also enabled we don't know if is using these ports, so Traefik may not work. Can we disable Apache?\n(we need sudo privileges)" \
|
|
--defaultno --title "Disable Apache" --backtitle "${BACK_TITLE}" 12 112); then
|
|
sudo systemctl stop apache2.service
|
|
sudo systemctl disable apache2.service
|
|
fi
|
|
}
|
|
}
|
|
|
|
# lock a folder path
|
|
function lockFolder() {
|
|
cat <<EOF
|
|
# Apache 2.4+
|
|
<IfModule mod_authz_core.c>
|
|
Require all denied
|
|
</IfModule>
|
|
|
|
# Apache 2.0-2.2
|
|
<IfModule !mod_authz_core.c>
|
|
Deny from all
|
|
</IfModule>
|
|
EOF
|
|
}
|
|
|
|
# clear the main environment variables
|
|
function quitProgram() {
|
|
####### CLEAR ALL
|
|
unset VDM_PUID
|
|
unset VDM_PGID
|
|
unset VDM_CONTAINER_TYPE
|
|
unset VDM_TASK
|
|
unset VDM_SRC_PATH
|
|
unset VDM_REPO_PATH
|
|
unset VDM_PROJECT_PATH
|
|
unset VDM_DOMAIN
|
|
unset VDM_MULTI_DOMAIN
|
|
unset VDM_SECURE
|
|
unset VDM_SECURE_CLOUDFLARE
|
|
unset VDM_UPDATE_HOST
|
|
unset VDM_CONTAINER
|
|
unset VDM_ACCESS_TOKEN
|
|
# exit at this point
|
|
exit 0
|
|
}
|
|
|
|
# do we allow multiple domains
|
|
function allowMultiDomains() {
|
|
# Allow multiple domains
|
|
setMultiDomainSwitch
|
|
# allow multi domain setup
|
|
if $VDM_MULTI_DOMAIN; then
|
|
# yes we do
|
|
return 0
|
|
fi
|
|
# now we don't
|
|
return 12
|
|
}
|
|
|
|
# do we allow multiple domains
|
|
function allowEditHostFile() {
|
|
# check if we allow host file updates
|
|
setUpdateHostFile
|
|
# allow multi domain setup
|
|
if $VDM_UPDATE_HOST; then
|
|
# yes we do
|
|
return 0
|
|
fi
|
|
# now we don't
|
|
return 12
|
|
}
|
|
|
|
# to set a global multiple domain file and values
|
|
function saveMultiDomain() {
|
|
# set some locals
|
|
local domain_name
|
|
local src_path_domain
|
|
# set the domain and remove any whitespace
|
|
domain_name="$(echo -e "${1}" | tr -d '[:space:]')"
|
|
src_path_domain="${VDM_SRC_PATH}/.domains"
|
|
# check that we have a domain string
|
|
if [ -n "${domain_name}" ]; then
|
|
# make sure the folder exists
|
|
mkdir -p "${VDM_SRC_PATH}"
|
|
# if the file does not exist, create it and set the proper permissions
|
|
if [ ! -f "${src_path_domain}" ]; then
|
|
touch "${src_path_domain}"
|
|
chmod 600 "${src_path_domain}"
|
|
fi
|
|
# check if the domain is not already in the file, and if not, add it
|
|
if ! grep -q "${domain_name}" "${src_path_domain}"; then
|
|
echo "${domain_name}" >>"${src_path_domain}"
|
|
fi
|
|
fi
|
|
# we return true
|
|
return 0
|
|
}
|
|
|
|
# delete a global Environment Variable
|
|
function deleteEnvVariable() {
|
|
# some locals
|
|
local env_key
|
|
# check if the env file exist
|
|
if [ -f "${VDM_SRC_PATH}/.env" ]; then
|
|
# check that we have the key
|
|
env_key="${1:-none}"
|
|
# shellcheck disable=SC2015
|
|
grep -vx "${env_key}=.*" "${VDM_SRC_PATH}/.env" >"${VDM_SRC_PATH}/.env_tmp" &&
|
|
mv "${VDM_SRC_PATH}/.env_tmp" "${VDM_SRC_PATH}/.env" ||
|
|
rm "${VDM_SRC_PATH}/.env_tmp"
|
|
fi
|
|
}
|
|
|
|
# delete multiple domains
|
|
function deleteMultiDomains() {
|
|
local menu_options=()
|
|
local domains
|
|
local i=0
|
|
local domain_file="${VDM_SRC_PATH}/.domains"
|
|
|
|
if [ -f "${domain_file}" ] && readarray -t domains <"${domain_file}"; then
|
|
if [ "${#domains[@]}" -gt 0 ]; then
|
|
for domain in "${domains[@]}"; do
|
|
menu_options+=("${domain}" "${domain}" "OFF")
|
|
i=$((i + 1))
|
|
done
|
|
|
|
answer=$(whiptail --title "Delete Domains" --checklist \
|
|
"Select the domain/s you would like to delete" 20 112 $i \
|
|
"${menu_options[@]}" \
|
|
--backtitle "${BACK_TITLE}" --nocancel --notags 3>&1 1>&2 2>&3)
|
|
|
|
if [ -n "${answer}" ]; then
|
|
IFS=' ' read -r -a array_answer <<<"${answer[@]}"
|
|
for remove in "${array_answer[@]}"; do
|
|
remove_domain="${remove//\"/}"
|
|
# shellcheck disable=SC2015
|
|
grep -vx "${remove_domain}" "${domain_file}" >"${domain_file}_tmp" && \
|
|
mv "${domain_file}_tmp" "${domain_file}" || \
|
|
rm "${domain_file}_tmp"
|
|
done
|
|
fi
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# check if expert mode is on
|
|
function isExpert() {
|
|
# check if its set
|
|
if [ -n "${VDM_EXPERT_MODE}" ] && [ "${VDM_EXPERT_MODE}" = "true" ]; then
|
|
# is expert
|
|
return 0
|
|
else
|
|
# not expert
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# check if some thing is a function
|
|
function isFunc() {
|
|
declare -F "$1" >/dev/null
|
|
}
|
|
|
|
# update the host file
|
|
function updateHostFile() {
|
|
# check if we should add to host file
|
|
if allowEditHostFile; then
|
|
# check if already in host file
|
|
if grep -q "${1:-$VDM_SUBDOMAIN}.${2:-$VDM_DOMAIN}" /etc/hosts; then
|
|
showNotice "${USER^}, ${1:-$VDM_SUBDOMAIN}.${2:-$VDM_DOMAIN} is already in the /etc/hosts file."
|
|
elif (whiptail --yesno "${USER^}, to add the ${1:-$VDM_SUBDOMAIN}.${2:-$VDM_DOMAIN} entry to your host file we need sudo privileges." \
|
|
--title "Give sudo Privileges" --backtitle "${BACK_TITLE}" 8 112); then
|
|
# add the domain to the host file
|
|
echo "127.0.0.1 ${1:-$VDM_SUBDOMAIN}.${2:-$VDM_DOMAIN}" | sudo tee -a /etc/hosts >/dev/null
|
|
# show notice
|
|
showNotice "${USER^}, ${1:-$VDM_SUBDOMAIN}.${2:-$VDM_DOMAIN} was added to the /etc/hosts file."
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# the manually edit the host file
|
|
function editHostFile() {
|
|
# check if we should add to host file
|
|
if allowEditHostFile; then
|
|
# if this container is enabled ask if it should be redeployed
|
|
if (whiptail --yesno "To edit the host file we need sudo privileges.\n[Only continue if you know what your doing!]" \
|
|
--title "Give sudo Privileges" --backtitle "${BACK_TITLE}" 15 112); then
|
|
# give little heads-up
|
|
showNotice "${USER^}, to save the changes you've made or to just close the file again press:\n\n[ctrl+x] with nano on ubuntu." 13
|
|
# lets open the file with nano for now
|
|
sudo "${EDITOR:-nano}" /etc/hosts
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# the manually edit the config file
|
|
function editConfigFile() {
|
|
# check if the file exist
|
|
if [ -f "${VDM_SRC_PATH}/.env" ]; then
|
|
# give little warning for less command ready people
|
|
if (whiptail --yesno "Only continue if you know what your doing!\n\n\
|
|
${USER^}, to save the changes you've made or to just close the file again press:\n\n\
|
|
[ctrl+x] with nano on ubuntu." --title "Continue to edit ${PROGRAM_NAME} global config." \
|
|
--backtitle "${BACK_TITLE}" 15 112); then
|
|
# all direct edit of the global config file
|
|
"${EDITOR:-nano}" "${VDM_SRC_PATH}/.env"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# the manually edit the container env file
|
|
function openEnv() {
|
|
# some local values
|
|
local container_type="$1"
|
|
# check if the file exist
|
|
if [ -f "${VDM_REPO_PATH}/${container_type}/.env" ]; then
|
|
# give little warning for less command ready people
|
|
if (whiptail --yesno "Only continue if you know what your doing!\n\n\
|
|
${USER^}, to save the changes you've made or to just close the file again press:\n\n\
|
|
[ctrl+x] with nano on ubuntu." --title "Continue to edit ${PROGRAM_NAME} ${container_type} env." \
|
|
--backtitle "${BACK_TITLE}" 15 112); then
|
|
# all direct edit of the container env file
|
|
"${EDITOR:-nano}" "${VDM_REPO_PATH}/${container_type}/.env"
|
|
fi
|
|
else
|
|
showError "${VDM_REPO_PATH}/${container_type}/.env does not exist, make sure you have at least one ${container_type} setup."
|
|
fi
|
|
}
|
|
|
|
# Check if any hosts are set in the SSH config file
|
|
function hasRemoteSystemSet() {
|
|
local ssh_config="/home/${USER}/.ssh/config"
|
|
|
|
if [ ! -d "/home/${USER}/.ssh" ] || [ ! -f "${ssh_config}" ] ||
|
|
[[ $(grep -i -c '^host' "${ssh_config}") -eq 0 ]]; then
|
|
showError "To use this feature you must first set up the needed remote host details in (~/.ssh/config) to allow easy and secure SSH access."
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
# Get a selected remote system
|
|
function getRemoteSystem() {
|
|
# The selected folder
|
|
local answer
|
|
|
|
if [ -f "/home/${USER}/.ssh/config" ]; then
|
|
# We start the selection array
|
|
local selected=()
|
|
# Our counter
|
|
local i=0
|
|
# Add the remote systems
|
|
while IFS= read -r remote_system; do
|
|
# Load the remote systems
|
|
selected+=("${remote_system}" "${remote_system}" "OFF")
|
|
# Increment our pointer
|
|
if [ "$i" -le 10 ]; then
|
|
i=$((i + 1))
|
|
fi
|
|
done < <(grep -i '^host' "/home/${USER}/.ssh/config" | awk '{print $2}' | sort)
|
|
|
|
# Add manual input option
|
|
selected+=("Enter manually" "Enter manually" "OFF")
|
|
|
|
# now make the selection
|
|
answer=$(whiptail --title "Remote Systems" --radiolist \
|
|
"Select the remote system you would like to use." 20 112 $i \
|
|
"${selected[@]}" --backtitle "${BACK_TITLE}" --notags 3>&1 1>&2 2>&3)
|
|
|
|
if [[ $answer == "Enter manually" ]]; then
|
|
answer=$(getInputNow "Enter the remote host manually:" "" "Remote Host")
|
|
fi
|
|
else
|
|
answer=$(getInputNow "Enter the remote host:" "" "Remote Host")
|
|
fi
|
|
|
|
# Return the answer
|
|
echo "${answer:-none_selected}"
|
|
}
|
|
|
|
# get a selected migration type
|
|
function getMigrationType() {
|
|
# the selected folder
|
|
local answer
|
|
# we start the selection array
|
|
local selected=()
|
|
# our counter
|
|
local i=2
|
|
# now check if this dir has sub dirs
|
|
selected+=("push" "Push to Remote System" "ON")
|
|
selected+=("pull" "Pull from Remote System" "OFF")
|
|
# now make the selection
|
|
answer=$(whiptail --title "Migration Type" --radiolist \
|
|
"What kind of migration will be preformed?" 20 112 $i \
|
|
"${selected[@]}" --backtitle "${BACK_TITLE}" --nocancel --notags 3>&1 1>&2 2>&3)
|
|
# return the answer
|
|
echo "${answer:-push}"
|
|
}
|
|
|
|
# Check if the remote .env file exists
|
|
function remoteEnvFileExists() {
|
|
local remote_system="$1"
|
|
|
|
# Check if the file exists on the remote system
|
|
# shellcheck disable=SC2029
|
|
ssh "${remote_system}" "[ -f \"/home/${USER}/.config/octojoom/.env\" ]"
|
|
}
|
|
|
|
# Get a specific value from the remote .env file
|
|
function getRemoteEnvValue() {
|
|
local remote_system="$1"
|
|
local env_key="$2"
|
|
local remote_env_value
|
|
|
|
if remoteEnvFileExists "${remote_system}"; then
|
|
# shellcheck disable=SC2029
|
|
remote_env_value=$(ssh "${remote_system}" "grep '^${env_key}=' \"/home/${USER}/.config/octojoom/.env\"" | cut -d '=' -f 2-)
|
|
fi
|
|
|
|
# Remove any double quotes from the returned value
|
|
remote_env_value=$(echo "${remote_env_value}" | tr -d '"')
|
|
|
|
echo "${remote_env_value:-none_found}"
|
|
}
|
|
|
|
# Pull the remote container migration
|
|
function pullContainerMigration() {
|
|
# set some local variables
|
|
local local_path="$1"
|
|
local container_path="$2"
|
|
local remote="$3"
|
|
local remote_repo_path
|
|
|
|
remote_repo_path=$(getRemoteEnvValue "${remote}" "VDM_REPO_PATH")
|
|
if [ ! "${remote_repo_path}" = 'none_found' ]; then
|
|
showNotice "PULL<<[NOT READY]>>DETAILS>> ${local_path}<-path ${container_path}<-container name ${remote}<-remote (${remote_repo_path})" 13
|
|
else
|
|
showError "Remote system does not appear to have ${PROGRAM_NAME} installed, or your access was denied. Therefore the migration has been cancelled!"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Push the remote container migration
|
|
function pushContainerMigration() {
|
|
# set some local variables
|
|
local local_path="$1"
|
|
local container_path="$2"
|
|
local remote="$3"
|
|
local remote_repo_path
|
|
|
|
remote_repo_path=$(getRemoteEnvValue "${remote}" "VDM_REPO_PATH")
|
|
if [ ! "${remote_repo_path}" = 'none_found' ]; then
|
|
local remote_path="${remote_repo_path}/${container_path}"
|
|
# check how we must do this
|
|
if remoteFolderExists "${remote_path}" "${remote}" && (whiptail --yesno "${USER^}, would you like to backup the remote container?" \
|
|
--backtitle "${BACK_TITLE}" --title "Backup Remote" 15 112); then
|
|
backupRemoteFolder "${remote_path}" "${remote}"
|
|
fi
|
|
# sync folder
|
|
syncWithRemote "${local_path}" "${remote_path}" "${remote}"
|
|
# check if it was done successfully
|
|
if transferWasSuccessful "${local_path}" "${remote_path}" "${remote}"; then
|
|
showNotice "The PUSH of ${local_path} to ${remote}:${remote_path} was a success." 13
|
|
return 0
|
|
else
|
|
showError "The PUSH of ${local_path} to ${remote}:${remote_path} failed."
|
|
return 1
|
|
fi
|
|
else
|
|
showError "Remote system does not appear to have ${PROGRAM_NAME} installed, or your access was denied. Therefore the migration has been cancelled!"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Pull the remote directory migration
|
|
function pullDirectoryMigration() {
|
|
# set some local variables
|
|
local local_path="$1"
|
|
local directory_name="$2"
|
|
local remote="$3"
|
|
local remote_project_path
|
|
|
|
remote_project_path=$(getRemoteEnvValue "${remote}" "VDM_PROJECT_PATH")
|
|
if [ ! "${remote_project_path}" = 'none_found' ]; then
|
|
showNotice "PULL<<[NOT READY]>>DETAILS>> ${local_path}<-path ${directory_name}<-directory name ${remote}<-remote (${remote_project_path})" 13
|
|
else
|
|
showError "Remote system does not appear to have ${PROGRAM_NAME} installed, or your access was denied. Therefore the migration has been cancelled!"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Push the remote directory migration
|
|
function pushDirectoryMigration() {
|
|
# set some local variables
|
|
local local_path="$1"
|
|
local directory_name="$2"
|
|
local remote="$3"
|
|
local remote_project_path
|
|
|
|
remote_project_path=$(getRemoteEnvValue "${remote}" "VDM_PROJECT_PATH")
|
|
if [ ! "${remote_project_path}" = 'none_found' ]; then
|
|
local backup_dir
|
|
local remote_path="${remote_project_path}/${directory_name}"
|
|
# make a backup of this project directory
|
|
backup_dir=$(createTempBackup "${local_path}")
|
|
# give current user full ownership of this folder
|
|
chownBackup "${backup_dir}"
|
|
# tar the directory
|
|
tar_path=$(tarAndMoveTempBackup "${local_path}" "${backup_dir}")
|
|
# clear the backup
|
|
rm -rf "${backup_dir}"
|
|
# move zip file to remote
|
|
moveTarToRemote "${tar_path}" "${remote_project_path}/" "${remote}"
|
|
# check if it was done successfully
|
|
if transferTarWasSuccessful "${tar_path}" "${remote_path}.tar.gz" "${remote}"; then
|
|
# clear the tmp tar
|
|
rm -rf "${tar_path}"
|
|
# check how we must do this
|
|
if remoteFolderExists "${remote_path}" "${remote}" &&
|
|
(whiptail --yesno "${USER^}, would you like to backup the remote directory?" \
|
|
--title "Backup Remote" --backtitle "${BACK_TITLE}" 15 112);
|
|
then
|
|
backupRemoteFolder "${remote_path}" "${remote}"
|
|
fi
|
|
# un-tar the remote file
|
|
remoteUntarGz "${remote_path}.tar.gz" "${remote_path}" "${remote}"
|
|
# we are done
|
|
showNotice "The PUSH of ${local_path} to ${remote}:${remote_path} was a success." 13
|
|
# permission fix
|
|
if (whiptail --yesno "${USER^}, would you like to fix the permissions of this remote directory?\nWe will start the ${PROGRAM_NAME} on the remote server and then you should navigate to the fix, and exit when done." \
|
|
--title "Permissions Fix" --backtitle "${BACK_TITLE}" 15 112); then
|
|
connectToRemoteSystem "${remote}"
|
|
fi
|
|
return 0
|
|
else
|
|
showError "The PUSH of ${local_path} to ${remote}:${remote_path} failed."
|
|
return 1
|
|
fi
|
|
else
|
|
showError "Remote system does not appear to have ${PROGRAM_NAME} installed, or your access was denied. Therefore the migration has been cancelled!"
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Create a temporary backup of the folder with root access
|
|
function createTempBackup() {
|
|
local source_dir="$1"
|
|
# shellcheck disable=SC2155
|
|
local backup_dir="/tmp/backup_$(basename "${source_dir}")_$(date +%Y%m%d%H%M%S)"
|
|
sudo cp -a "${source_dir}" "${backup_dir}"
|
|
echo "${backup_dir}"
|
|
}
|
|
|
|
# Create a tar.gz archive of the temporary backup folder and move the resulting archive to the parent directory of the source directory
|
|
function tarAndMoveTempBackup() {
|
|
local source_dir="$1"
|
|
local backup_dir="$2"
|
|
local parent_dir
|
|
local tar_filename
|
|
local current_dir
|
|
|
|
# Get the parent directory of the source directory
|
|
parent_dir=$(dirname "${source_dir}")
|
|
|
|
# Create the tar.gz filename
|
|
tar_filename="$(basename "${source_dir}").tar.gz"
|
|
|
|
# Store the current working directory
|
|
current_dir=$(pwd)
|
|
|
|
# Change to the backup directory
|
|
cd "${backup_dir}" || return
|
|
|
|
# Create the tar.gz archive without preserving the full path
|
|
tar -czf "${parent_dir}/${tar_filename}" .
|
|
|
|
# Change back to the original working directory
|
|
cd "${current_dir}" || return
|
|
|
|
# Return the path to the moved tar.gz archive
|
|
echo "${parent_dir}/${tar_filename}"
|
|
}
|
|
|
|
# Change the ownership of the backup directory to the current user
|
|
function chownBackup() {
|
|
local backup_dir="$1"
|
|
sudo chown -R "${USER}":"${USER}" "${backup_dir}"
|
|
}
|
|
|
|
# Check if the folder exists on the remote server
|
|
function remoteFolderExists() {
|
|
local remote_path="$1"
|
|
local remote="$2"
|
|
|
|
# Check if the remote folder exists
|
|
# shellcheck disable=SC2029
|
|
if ssh "${remote}" "[ -d '${remote_path}' ]"; then
|
|
return 0
|
|
else
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# run Octojoom on a remote system
|
|
function connectToRemoteSystem() {
|
|
# set some local variables
|
|
local remote_system="${1:-none_set}"
|
|
local remote_repo_path
|
|
# get remote system
|
|
if [ "${remote_system}" == "none_set" ]; then
|
|
remote_system=$(getRemoteSystem)
|
|
fi
|
|
# make sure we have a remote
|
|
if [ ${#remote_system} -ge 2 ] && [ "${remote_system}" != "none_selected" ]; then
|
|
showNotice "We will first validate that the remote system has ${PROGRAM_NAME,,} config settings in place!" 13
|
|
if remoteEnvFileExists "${remote_system}"; then
|
|
if (whiptail --yesno "${USER^} we found ${PROGRAM_NAME,,} config settings on the ${remote_system}. Please take note of the following important information.\n\nSince we will start ${PROGRAM_NAME,,} on ${remote_system} it will not look that different, seeing that it has the same user graphical interface. Yet, whatever changes you make on ${remote_system} WILL PERMINANTLY effect this remote system, and can not be undone!!!\n\nAre you ready to connect to ${remote_system}:${PROGRAM_NAME,,}?" \
|
|
--title "Confirm ${remote_system} Connection" --backtitle "${BACK_TITLE}" 15 112); then
|
|
showNotice "Connection to ${remote_system} will now be made!" 13
|
|
ssh -t "${remote_system}" "bash octojoom"
|
|
showNotice "You have been disconnected from ${remote_system}!" 13
|
|
return 0
|
|
else
|
|
showNotice "The connection to ${remote_system} was cancelled!" 13
|
|
return 1
|
|
fi
|
|
else
|
|
showError "Remote system does not appear to have ${PROGRAM_NAME,,} installed, or your access was denied. Therefore the connection has been closed!"
|
|
return 1
|
|
fi
|
|
fi
|
|
showError "Connection to the remote system was cancelled since no remote system was selected."
|
|
return 1
|
|
}
|
|
|
|
# Change the ownership of the remote folder to the current user
|
|
function chownRemoteFolder() {
|
|
local remote_path="$1"
|
|
local remote="$2"
|
|
|
|
ssh -t "${remote}" "sudo chown -R ${USER}:${USER} ${remote_path}"
|
|
}
|
|
|
|
# Check if the folder exists on the remote server, and if so, rename it for backup purposes
|
|
function backupRemoteFolder() {
|
|
local remote_path="$1"
|
|
local remote="$2"
|
|
# shellcheck disable=SC2155
|
|
local backup_name="${remote_path}_backup_$(date +%Y%m%d%H%M%S)"
|
|
# shellcheck disable=SC2029
|
|
ssh "${remote}" "if [ -d '${remote_path}' ]; then mv '${remote_path}' '${backup_name}'; fi"
|
|
}
|
|
|
|
# Prep remote folder
|
|
function prepRemoteFolder() {
|
|
local remote_path="$1"
|
|
local remote="$2"
|
|
|
|
# shellcheck disable=SC2029
|
|
ssh "${remote}" "mkdir -p ${remote_path}"
|
|
}
|
|
|
|
# Remotely extract a tar.gz file to a specified folder on the remote host
|
|
function remoteUntarGz() {
|
|
local remote_file_path="$1"
|
|
local remote_extract_path="$2"
|
|
local remote="$3"
|
|
|
|
# Remote un-tar.gz command
|
|
# shellcheck disable=SC2029
|
|
ssh "${remote}" "mkdir -p '${remote_extract_path}' && tar --overwrite -xzf '${remote_file_path}' -C '${remote_extract_path}'"
|
|
# shellcheck disable=SC2029
|
|
ssh "${remote}" "if [ -f '${remote_file_path}' ]; then rm '${remote_file_path}'; fi"
|
|
}
|
|
|
|
# Transfer the folder to the remote server using rsync
|
|
function syncFolder() {
|
|
local local_path="$1"
|
|
local remote_path="$2"
|
|
local remote="$3"
|
|
rsync -avz --delete "${local_path}/" "${remote}:${remote_path}"
|
|
}
|
|
|
|
# Move/copy the local tar file to the remote server
|
|
function moveTarToRemote() {
|
|
local local_path="$1"
|
|
local remote_path="$2"
|
|
local remote="$3"
|
|
|
|
if [ -f "/home/${USER}/.ssh/config" ]; then
|
|
scp -F "/home/${USER}/.ssh/config" "${local_path}" "${remote}:${remote_path}"
|
|
else
|
|
scp "${local_path}" "${remote}:${remote_path}"
|
|
fi
|
|
}
|
|
|
|
# Sync the local folder to the remote server and remove the local backup
|
|
function syncWithRemote() {
|
|
local local_path="$1"
|
|
local remote_path="$2"
|
|
local remote="$3"
|
|
|
|
prepRemoteFolder "${remote_path}" "${remote}"
|
|
|
|
syncFolder "${local_path}" "${remote_path}" "${remote}"
|
|
}
|
|
|
|
# Check if the transfer was successful by comparing local and remote directory contents
|
|
function transferWasSuccessful() {
|
|
local local_path="$1"
|
|
local remote_path="$2"
|
|
local remote="$3"
|
|
|
|
# Perform a dry-run with rsync to compare directories
|
|
rsync_output=$(rsync -avz --dry-run --checksum --delete "${local_path}/" "${remote}:${remote_path}/")
|
|
|
|
# Check if there are any file differences or deletions
|
|
echo "${rsync_output}" | grep -E -q "^(>|<|deleting)"
|
|
|
|
# Check the exit status of the grep command to determine if there are any differences
|
|
# shellcheck disable=SC2181
|
|
if [ $? -eq 0 ]; then
|
|
# Differences found, return failure
|
|
return 1
|
|
else
|
|
# No differences found, return success
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
# Check if the transfer was successful by comparing local and remote zip file checksums
|
|
function transferTarWasSuccessful() {
|
|
local local_path="$1"
|
|
local remote_path="$2"
|
|
local remote="$3"
|
|
|
|
# Compute the checksum of the local zip file
|
|
local_checksum=$(md5sum "${local_path}" | awk '{print $1}')
|
|
|
|
# Compute the checksum of the remote zip file
|
|
# shellcheck disable=SC2029
|
|
remote_checksum=$(ssh "${remote}" "md5sum ${remote_path}" | awk '{print $1}')
|
|
|
|
# Compare the checksums
|
|
if [ "${local_checksum}" == "${remote_checksum}" ]; then
|
|
# Checksums match, return success
|
|
return 0
|
|
else
|
|
# Checksums do not match, return failure
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## CLI MENU ʕ•ᴥ•ʔ
|
|
|
|
# help message
|
|
function showHelp() {
|
|
cat <<EOF
|
|
Usage: octojoom [OPTION...]
|
|
Options
|
|
======================================================
|
|
--type <type>
|
|
set type you would like to work with
|
|
example: octojoom --type joomla
|
|
======================================================
|
|
--task <task>
|
|
set type of task you would like to perform
|
|
example: octojoom --task setup
|
|
======================================================
|
|
--container <container.domain.name>
|
|
Directly enabling or disabling a container with
|
|
the type=joomla and task=enable/disable set
|
|
The container must exist, which means it was
|
|
setup previously
|
|
Used without type and task Joomla-Enable is (default)
|
|
example: octojoom --container "io.vdm.dev"
|
|
======================================================
|
|
--update
|
|
to update your install
|
|
example: octojoom --update
|
|
======================================================
|
|
--access-token <token>
|
|
to update the program you will need an access token
|
|
from https://git.vdm.dev/user/settings/applications
|
|
example: octojoom --access-token xxxxxxxxxxx
|
|
======================================================
|
|
--uninstall
|
|
to uninstall this script
|
|
example: octojoom --uninstall
|
|
======================================================
|
|
AVAILABLE FOR TO ANY CONTAINER
|
|
======================================================
|
|
-k|--key <key>
|
|
set key for the docker compose container naming
|
|
!! no spaces allowed in the key !!
|
|
example: octojoom -k="vdm"
|
|
example: octojoom --key="vdm"
|
|
======================================================
|
|
-e|--env-key <key>
|
|
set key for the environment variable naming
|
|
!! no spaces allowed in the key & must be UPPERCASE !!
|
|
example: octojoom -e="VDM"
|
|
example: octojoom --env-key="VDM"
|
|
======================================================
|
|
-d|--domain <domain.com>
|
|
set key website domain
|
|
!! must be domain.tld !!
|
|
example: octojoom -d="joomla.org"
|
|
example: octojoom --domain="joomla.org"
|
|
======================================================
|
|
-s|--sub-domain <domain.com>
|
|
set key website sub domain
|
|
!! no spaces allowed in the sub domain !!
|
|
example: octojoom -s="jcb"
|
|
example: octojoom --sub-domain="jcb"
|
|
======================================================
|
|
AVAILABLE FOR JOOMLA CONTAINER
|
|
======================================================
|
|
-j|--joomla-version <version-tag>
|
|
see available tags here https://hub.docker.com/_/joomla
|
|
example: octojoom -j=5.0
|
|
example: octojoom --joomla-version=5.0
|
|
======================================================
|
|
AVAILABLE FOR OPENSSH CONTAINER
|
|
======================================================
|
|
-u|--username <username>
|
|
set username of the container
|
|
example: octojoom -u="ubuntu"
|
|
example: octojoom --username="ubuntu"
|
|
======================================================
|
|
--uid <id>
|
|
set container user id
|
|
example: octojoom --uid=1000
|
|
======================================================
|
|
--gid <id>
|
|
set container user group id
|
|
example: octojoom --gid=1000
|
|
======================================================
|
|
-p|--port <port>
|
|
set ssh port to use
|
|
!! do not use 22 !!
|
|
example: octojoom -p=2239
|
|
example: octojoom --port=2239
|
|
======================================================
|
|
--ssh-dir <dir>
|
|
set ssh directory name found in the .ssh dir
|
|
of this repo for the container keys
|
|
This directory has separate files for
|
|
each public key allowed to access
|
|
the container
|
|
example: octojoom --ssh-dir="teamname"
|
|
======================================================
|
|
--sudo
|
|
switch to add the container user to the
|
|
sudo group of the container
|
|
example: octojoom --sudo
|
|
======================================================
|
|
-t|--time-zone <time/zone>
|
|
set time zone of the container
|
|
!! must valid time zone !!
|
|
example: octojoom -t="Africa/Windhoek"
|
|
example: octojoom --time-zone="Africa/Windhoek"
|
|
======================================================
|
|
HELP ʕ•ᴥ•ʔ
|
|
======================================================
|
|
-h|--help
|
|
display this help menu
|
|
example: octojoom -h
|
|
example: octojoom --help
|
|
======================================================
|
|
${PROGRAM_NAME} v${_VERSION}
|
|
======================================================
|
|
EOF
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## CLI INPUT ¯\_(ツ)_/¯
|
|
|
|
# defaults
|
|
VDM_ARG_DOMAIN=false
|
|
|
|
# check if we have options
|
|
while :; do
|
|
case $1 in
|
|
-h | --help)
|
|
showHelp # Display a usage synopsis.
|
|
quitProgram
|
|
;;
|
|
--update)
|
|
runUpdate
|
|
shift
|
|
;;
|
|
--access-token) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_ACCESS_TOKEN=$2
|
|
shift
|
|
else
|
|
showError '"--access-token" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--access-token=?*)
|
|
# shellcheck disable=SC2034
|
|
VDM_ACCESS_TOKEN=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
--access-token=) # Handle the case of an empty --type=
|
|
showError '"--access-token=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--uninstall)
|
|
runUninstall
|
|
shift
|
|
;;
|
|
--type) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_CONTAINER_TYPE=$2
|
|
shift
|
|
else
|
|
showError '"--type" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--type=?*)
|
|
VDM_CONTAINER_TYPE=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
--type=) # Handle the case of an empty --type=
|
|
showError '"--type=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--task) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_TASK=$2
|
|
shift
|
|
else
|
|
showError '"--task" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--task=?*)
|
|
VDM_TASK=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
--task=) # Handle the case of an empty --task=
|
|
showError '"--task=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--container) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_CONTAINER=$2
|
|
shift
|
|
else
|
|
showError '"--container" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--container=?*)
|
|
VDM_CONTAINER=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
--container=) # Handle the case of an empty --container=
|
|
showError '"--container=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-j | --joomla-version) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_JV=$2
|
|
shift
|
|
else
|
|
showError '"--joomla-version" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-j=?* | --joomla-version=?*)
|
|
VDM_JV=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-j= | --joomla-version=) # Handle the case of an empty --joomla-version=
|
|
showError '"--joomla-version=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-k | --key) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_KEY=$2
|
|
shift
|
|
else
|
|
showError '"--key" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-k=?* | --key=?*)
|
|
VDM_KEY=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-k= | --key=) # Handle the case of an empty --key=
|
|
showError '"--key=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-e | --env-key) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_ENV_KEY=$2
|
|
shift
|
|
else
|
|
showError '"--env-key" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-e=?* | --env-key=?*)
|
|
VDM_ENV_KEY=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-e= | --env-key=) # Handle the case of an empty --env-key=
|
|
showError '"--env-key=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-d | --domain) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_DOMAIN=$2
|
|
# set the ARG domain as true
|
|
VDM_ARG_DOMAIN=true
|
|
shift
|
|
else
|
|
showError '"--domain" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-d=?* | --domain=?*)
|
|
VDM_DOMAIN=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
# set the ARG domain as true
|
|
VDM_ARG_DOMAIN=true
|
|
;;
|
|
-d= | --domain=) # Handle the case of an empty --domain=
|
|
showError '"--domain=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-s | --sub-domain) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_SUBDOMAIN=$2
|
|
shift
|
|
else
|
|
showError '"--sub-domain" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-s=?* | --sub-domain=?*)
|
|
VDM_SUBDOMAIN=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-s= | --sub-domain=) # Handle the case of an empty --sub-domain=
|
|
showError '"--sub-domain=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--sudo)
|
|
VDM_SUDO_ACCESS=true
|
|
shift
|
|
;;
|
|
-u | --username) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_USER_NAME=$2
|
|
shift
|
|
else
|
|
showError '"--username" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-u=?* | --username=?*)
|
|
VDM_USER_NAME=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-u= | --username=) # Handle the case of an empty --username=
|
|
showError '"--username=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--uid) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_PUID=$2
|
|
shift
|
|
else
|
|
showError '"--uid" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--uid=?*)
|
|
VDM_PUID=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
--uid=) # Handle the case of an empty --uid=
|
|
showError '"--uid=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--gid) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_PGID=$2
|
|
shift
|
|
else
|
|
showError '"--gid" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--gid=?*)
|
|
VDM_PGID=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
--gid=) # Handle the case of an empty --gid=
|
|
showError '"--gid=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-p | --port) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_PORT=$2
|
|
shift
|
|
else
|
|
showError '"--port" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-p=?* | --port=?*)
|
|
VDM_PORT=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-p= | --port=) # Handle the case of an empty --port=
|
|
showError '"--port=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
--ssh-dir) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_PUBLIC_KEY_DIR=$2
|
|
shift
|
|
else
|
|
showError '"--ssh-dir" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
--ssh-dir=?*)
|
|
VDM_PUBLIC_KEY_DIR=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-ssh-dir=) # Handle the case of an empty --ssh-dir=
|
|
showError '"--ssh-dir=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
-t | --time-zone) # Takes an option argument; ensure it has been specified.
|
|
if [ "$2" ]; then
|
|
VDM_TZ=$2
|
|
shift
|
|
else
|
|
showError '"--time-zone" requires a non-empty option argument.'
|
|
exit 17
|
|
fi
|
|
;;
|
|
-t=?* | --time-zone=?*)
|
|
VDM_TZ=${1#*=} # Delete everything up to "=" and assign the remainder.
|
|
;;
|
|
-t= | --time-zone=) # Handle the case of an empty --time-zone=
|
|
showError '"--time-zone=" requires a non-empty option argument.'
|
|
exit 17
|
|
;;
|
|
*) # Default case: No more options, so break out of the loop.
|
|
break ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## CLI PREP
|
|
|
|
# set the type and task if we have a container value
|
|
if [ ${#VDM_CONTAINER} -ge 1 ]; then
|
|
# check that the type is set (default Joomla)
|
|
VDM_CONTAINER_TYPE="${VDM_CONTAINER_TYPE:-joomla}"
|
|
# check that the task is set (default enable)
|
|
VDM_TASK="${VDM_TASK:-enable}"
|
|
fi
|
|
|
|
# set the container value if we have type and task set and not the container value
|
|
if [ ${#VDM_CONTAINER} -le 1 ] &&
|
|
[ ${#VDM_CONTAINER_TYPE} -ge 1 ] &&
|
|
[ ${#VDM_TASK} -ge 1 ] &&
|
|
[ ${#VDM_DOMAIN} -ge 1 ]; then
|
|
# we set the sub based on what was set
|
|
sub=''
|
|
if [ ${#VDM_SUBDOMAIN} -ge 1 ]; then
|
|
sub="${VDM_SUBDOMAIN}"
|
|
elif [ "${VDM_CONTAINER_TYPE}" = 'portainer' ]; then
|
|
sub="port"
|
|
elif [ "${VDM_CONTAINER_TYPE}" = 'traefik' ]; then
|
|
sub="traefik"
|
|
elif [ ${#VDM_USER_NAME} -ge 1 ]; then
|
|
sub="${VDM_USER_NAME}"
|
|
fi
|
|
# check if we now have a value
|
|
if [ ${#sub} -le 1 ]; then
|
|
showError 'Setting the type and task, and not setting the container details will require further input.'
|
|
else
|
|
# we set the container defaults based an user input
|
|
VDM_CONTAINER="${sub:-vdm}.${VDM_DOMAIN}"
|
|
fi
|
|
fi
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## SETUP KEY PATHS
|
|
# the src folder path is where we store the script global env
|
|
VDM_SRC_PATH="/home/${USER}/.config/octojoom"
|
|
# create the folder if not set
|
|
# shellcheck disable=SC2174
|
|
mkdir -p -m '700' "${VDM_SRC_PATH}"
|
|
# first run switch
|
|
VDM_FIRST_RUN=false
|
|
# load the globals
|
|
# shellcheck disable=SC1090 source=/dev/null
|
|
[ -f "${VDM_SRC_PATH}/.env" ] && source "${VDM_SRC_PATH}/.env"
|
|
# get repo path where store the container deploy scripts
|
|
while [ ${#VDM_REPO_PATH} -le 1 ] || [ ! -d "${VDM_REPO_PATH}" ]; do
|
|
# creat the path if it exist
|
|
if [ ${#VDM_REPO_PATH} -ge 1 ] && (whiptail --yesno "Can we create the ${VDM_REPO_PATH} repository folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
mkdir -p "${VDM_REPO_PATH}"
|
|
else
|
|
# get the value
|
|
VDM_REPO_PATH=$(getInput "Enter the repository path where we can store the containers' docker-composer.yml deployment files." \
|
|
"/home/${USER}/Docker" 'Enter Repository Path')
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_REPO_PATH} -ge 1 ] && [ ! -d "${VDM_REPO_PATH}" ] && (whiptail --yesno "Can we create the ${VDM_REPO_PATH} repository folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
mkdir -p "${VDM_REPO_PATH}"
|
|
elif [ ${#VDM_REPO_PATH} -le 1 ]; then
|
|
showError "You must set a repository path where we can store the containers' docker-composer.yml deployment files."
|
|
fi
|
|
fi
|
|
# trip switch of first run
|
|
VDM_FIRST_RUN=true
|
|
done
|
|
# add this value if not set variable
|
|
setEnvVariable "VDM_REPO_PATH=\"${VDM_REPO_PATH}\""
|
|
# get repo path where store the container deploy scripts
|
|
while [ ${#VDM_PROJECT_PATH} -le 1 ] || [ ! -d "${VDM_PROJECT_PATH}" ]; do
|
|
# create the path if it exist
|
|
if [ ${#VDM_PROJECT_PATH} -ge 1 ] && (whiptail --yesno "Can we create the ${VDM_PROJECT_PATH} projects' folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
mkdir -p "${VDM_PROJECT_PATH}"
|
|
else
|
|
# get the value
|
|
VDM_PROJECT_PATH=$(getInput "Enter the projects' path where we can store the containers' persistent volumes." \
|
|
"/home/${USER}/Projects" "Enter Projects' Path")
|
|
# keep asking if empty or does exist
|
|
if [ ${#VDM_PROJECT_PATH} -ge 1 ] && [ ! -d "${VDM_PROJECT_PATH}" ] && (whiptail --yesno "Can we create the ${VDM_PROJECT_PATH} projects folder" \
|
|
--title "Create the Path" --backtitle "${BACK_TITLE}" 8 112); then
|
|
mkdir -p "${VDM_PROJECT_PATH}"
|
|
elif [ ${#VDM_PROJECT_PATH} -le 1 ]; then
|
|
showError "You must set a projects' path where we can store the containers' persistent volumes."
|
|
fi
|
|
fi
|
|
# trip switch of first run
|
|
VDM_FIRST_RUN=true
|
|
done
|
|
# add this value if not set variable
|
|
setEnvVariable "VDM_PROJECT_PATH=\"${VDM_PROJECT_PATH}\""
|
|
# set these globally
|
|
export VDM_REPO_PATH
|
|
export VDM_PROJECT_PATH
|
|
# if this is the first run we should setup traefik
|
|
$VDM_FIRST_RUN && {
|
|
# set traefik as the container type
|
|
: "${VDM_CONTAINER_TYPE:=traefik}"
|
|
# and enable it
|
|
: "${VDM_TASK:=setup}"
|
|
# first setup the network
|
|
setNetworks
|
|
# trigger main
|
|
main
|
|
# clear it again
|
|
VDM_CONTAINER_TYPE=''
|
|
VDM_TASK=''
|
|
}
|
|
|
|
#####################################################################################################################VDM
|
|
######################################## MAIN ┬┴┬┴┤(・_├┬┴┬┴
|
|
main
|