#!/bin/bash

####################################################################################################
#### author: SlickStack ############################################################################
#### link: https://slickstack.io ###################################################################
#### mirror: https://mirrors.slickstack.io/bash/ss-check.txt #######################################
#### path: /var/www/ss-check #######################################################################
#### destination: n/a (not a boilerplate) ##########################################################
#### purpose: Retrieves all cron jobs and bash scripts (except for ss-check) #######################
#### module version: Ubuntu 22.04 LTS ##############################################################
#### sourced by: ss-install, ss-update-modules #####################################################
#### bash aliases: ss check ########################################################################
####################################################################################################

## source ss-config ##
source /var/www/ss-config

## source ss-functions ##
source /var/www/ss-functions

## BELOW THIS RELIES ON SS-CONFIG AND SS-FUNCTIONS

####################################################################################################
#### TABLE OF CONTENTS (SS-Check) ##################################################################
####################################################################################################

## this is a brief summary of the different code snippets you will find in this script ##
## each section should be commented so you understand what is being accomplished ##

## A. Touch Timestamp File
## B. Message (Begin Script)
## C. Retrieve Cron Jobs
## D. Retrieve Custom Cron Job Boilerplates (If Not Exist)
## E. Retrieve Bash Scripts (Except SS-Check)
## F. Install Cron Jobs 
## G. Install Bash Scripts (Except SS-Check)

####################################################################################################
#### A. SS-Check: Touch Timestamp File #############################################################
####################################################################################################

## this is a dummy timestamp file that will remember the last time this script was run ##
## it can be useful for developer reference and is sometimes used by SlickStack ##

## script timestamp ##
ss_touch "${TIMESTAMP_SS_CHECK}"

####################################################################################################
#### B. SS-Check: Message (Begin Script) ###########################################################
####################################################################################################

## this is a simple message that announces to the shell the purpose of this bash script ##
## it will only be noticed by sudo users who manually call ss core bash scripts ##

## echo message ##
ss_echo "${COLOR_INFO}Running ss-check... ${COLOR_RESET}"

####################################################################################################
#### C. SS-Check: Retrieve Cron Jobs ###############################################################
####################################################################################################

## here we retrieve all the latest ss core cron jobs and bash scripts to keep them updated ##
## this process does not affect ss-config or LEMP modules, nor the ss-check file ##

## 00-crontab ##
ss_wget "${TMP_00_CRONTAB}" "${GITHUB_00_CRONTAB}"
VALIDATE_TMP_00_CRONTAB=$(grep 'SS_EOF' "${TMP_00_CRONTAB}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_00_CRONTAB}" ]]; then
    ss_wget "${TMP_00_CRONTAB}" "${GITLAB_00_CRONTAB}"
fi
VALIDATE2_TMP_00_CRONTAB=$(grep 'SS_EOF' "${TMP_00_CRONTAB}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_00_CRONTAB}" ]]; then
    ss_wget "${TMP_00_CRONTAB}" "${SOURCEFORGE_00_CRONTAB}"
fi

## 01-cron-often ##
ss_wget "${TMP_01_CRON_OFTEN}" "${GITHUB_01_CRON_OFTEN}"
VALIDATE_TMP_01_CRON_OFTEN=$(grep 'SS_EOF' "${TMP_01_CRON_OFTEN}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_01_CRON_OFTEN}" ]]; then
    ss_wget "${TMP_01_CRON_OFTEN}" "${GITLAB_01_CRON_OFTEN}"
fi
VALIDATE2_TMP_01_CRON_OFTEN=$(grep 'SS_EOF' "${TMP_01_CRON_OFTEN}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_01_CRON_OFTEN}" ]]; then
    ss_wget "${TMP_01_CRON_OFTEN}" "${SOURCEFORGE_01_CRON_OFTEN}"
fi

## 02-cron-regular ##
ss_wget "${TMP_02_CRON_REGULAR}" "${GITHUB_02_CRON_REGULAR}"
VALIDATE_TMP_02_CRON_REGULAR=$(grep 'SS_EOF' "${TMP_02_CRON_REGULAR}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_02_CRON_REGULAR}" ]]; then
    ss_wget "${TMP_02_CRON_REGULAR}" "${GITLAB_02_CRON_REGULAR}"
fi
VALIDATE2_TMP_02_CRON_REGULAR=$(grep 'SS_EOF' "${TMP_02_CRON_REGULAR}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_02_CRON_REGULAR}" ]]; then
    ss_wget "${TMP_02_CRON_REGULAR}" "${SOURCEFORGE_02_CRON_REGULAR}"
fi

## 03-cron-quarter-hourly ##
ss_wget "${TMP_03_CRON_QUARTER_HOURLY}" "${GITHUB_03_CRON_QUARTER_HOURLY}"
VALIDATE_TMP_03_CRON_QUARTER_HOURLY=$(grep 'SS_EOF' "${TMP_03_CRON_QUARTER_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_03_CRON_QUARTER_HOURLY}" ]]; then
    ss_wget "${TMP_03_CRON_QUARTER_HOURLY}" "${GITLAB_03_CRON_QUARTER_HOURLY}"
fi
VALIDATE2_TMP_03_CRON_QUARTER_HOURLY=$(grep 'SS_EOF' "${TMP_03_CRON_QUARTER_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_03_CRON_QUARTER_HOURLY}" ]]; then
    ss_wget "${TMP_03_CRON_QUARTER_HOURLY}" "${SOURCEFORGE_03_CRON_QUARTER_HOURLY}"
fi

## 04-cron-half-hourly ##
ss_wget "${TMP_04_CRON_HALF_HOURLY}" "${GITHUB_04_CRON_HALF_HOURLY}"
VALIDATE_TMP_04_CRON_HALF_HOURLY=$(grep 'SS_EOF' "${TMP_04_CRON_HALF_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_04_CRON_HALF_HOURLY}" ]]; then
    ss_wget "${TMP_04_CRON_HALF_HOURLY}" "${GITLAB_04_CRON_HALF_HOURLY}"
fi
VALIDATE2_TMP_04_CRON_HALF_HOURLY=$(grep 'SS_EOF' "${TMP_04_CRON_HALF_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_04_CRON_HALF_HOURLY}" ]]; then
    ss_wget "${TMP_04_CRON_HALF_HOURLY}" "${SOURCEFORGE_04_CRON_HALF_HOURLY}"
fi

## 05-cron-hourly ##
ss_wget "${TMP_05_CRON_HOURLY}" "${GITHUB_05_CRON_HOURLY}"
VALIDATE_TMP_05_CRON_HOURLY=$(grep 'SS_EOF' "${TMP_05_CRON_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_05_CRON_HOURLY}" ]]; then
    ss_wget "${TMP_05_CRON_HOURLY}" "${GITLAB_05_CRON_HOURLY}"
fi
VALIDATE2_TMP_05_CRON_HOURLY=$(grep 'SS_EOF' "${TMP_05_CRON_HOURLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_05_CRON_HOURLY}" ]]; then
    ss_wget "${TMP_05_CRON_HOURLY}" "${SOURCEFORGE_05_CRON_HOURLY}"
fi

## 06-cron-quarter-daily ##
ss_wget "${TMP_06_CRON_QUARTER_DAILY}" "${GITHUB_06_CRON_QUARTER_DAILY}"
VALIDATE_TMP_06_CRON_QUARTER_DAILY=$(grep 'SS_EOF' "${TMP_06_CRON_QUARTER_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_06_CRON_QUARTER_DAILY}" ]]; then
    ss_wget "${TMP_06_CRON_QUARTER_DAILY}" "${GITLAB_06_CRON_QUARTER_DAILY}"
fi
VALIDATE2_TMP_06_CRON_QUARTER_DAILY=$(grep 'SS_EOF' "${TMP_06_CRON_QUARTER_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_06_CRON_QUARTER_DAILY}" ]]; then
    ss_wget "${TMP_06_CRON_QUARTER_DAILY}" "${SOURCEFORGE_06_CRON_QUARTER_DAILY}"
fi

## 07-cron-half-daily ##
ss_wget "${TMP_07_CRON_HALF_DAILY}" "${GITHUB_07_CRON_HALF_DAILY}"
VALIDATE_TMP_07_CRON_HALF_DAILY=$(grep 'SS_EOF' "${TMP_07_CRON_HALF_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_07_CRON_HALF_DAILY}" ]]; then
    ss_wget "${TMP_07_CRON_HALF_DAILY}" "${GITLAB_07_CRON_HALF_DAILY}"
fi
VALIDATE2_TMP_07_CRON_HALF_DAILY=$(grep 'SS_EOF' "${TMP_07_CRON_HALF_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_07_CRON_HALF_DAILY}" ]]; then
    ss_wget "${TMP_07_CRON_HALF_DAILY}" "${SOURCEFORGE_07_CRON_HALF_DAILY}"
fi

## 08-cron-daily ##
ss_wget "${TMP_08_CRON_DAILY}" "${GITHUB_08_CRON_DAILY}"
VALIDATE_TMP_08_CRON_DAILY=$(grep 'SS_EOF' "${TMP_08_CRON_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_08_CRON_DAILY}" ]]; then
    ss_wget "${TMP_08_CRON_DAILY}" "${GITLAB_08_CRON_DAILY}"
fi
VALIDATE2_TMP_08_CRON_DAILY=$(grep 'SS_EOF' "${TMP_08_CRON_DAILY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_08_CRON_DAILY}" ]]; then
    ss_wget "${TMP_08_CRON_DAILY}" "${SOURCEFORGE_08_CRON_DAILY}"
fi

## 09-cron-half-weekly ##
ss_wget "${TMP_09_CRON_HALF_WEEKLY}" "${GITHUB_09_CRON_HALF_WEEKLY}"
VALIDATE_TMP_09_CRON_HALF_WEEKLY=$(grep 'SS_EOF' "${TMP_09_CRON_HALF_WEEKLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_09_CRON_HALF_WEEKLY}" ]]; then
    ss_wget "${TMP_09_CRON_HALF_WEEKLY}" "${GITLAB_09_CRON_HALF_WEEKLY}"
fi
VALIDATE2_TMP_09_CRON_HALF_WEEKLY=$(grep 'SS_EOF' "${TMP_09_CRON_HALF_WEEKLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_09_CRON_HALF_WEEKLY}" ]]; then
    ss_wget "${TMP_09_CRON_HALF_WEEKLY}" "${SOURCEFORGE_09_CRON_HALF_WEEKLY}"
fi

## 10-cron-weekly ##
ss_wget "${TMP_10_CRON_WEEKLY}" "${GITHUB_10_CRON_WEEKLY}"
VALIDATE_TMP_10_CRON_WEEKLY=$(grep 'SS_EOF' "${TMP_10_CRON_WEEKLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_10_CRON_WEEKLY}" ]]; then
    ss_wget "${TMP_10_CRON_WEEKLY}" "${GITLAB_10_CRON_WEEKLY}"
fi
VALIDATE2_TMP_10_CRON_WEEKLY=$(grep 'SS_EOF' "${TMP_10_CRON_WEEKLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_10_CRON_WEEKLY}" ]]; then
    ss_wget "${TMP_10_CRON_WEEKLY}" "${SOURCEFORGE_10_CRON_WEEKLY}"
fi

## 11-cron-half-monthly ##
ss_wget "${TMP_11_CRON_HALF_MONTHLY}" "${GITHUB_11_CRON_HALF_MONTHLY}"
VALIDATE_TMP_11_CRON_HALF_MONTHLY=$(grep 'SS_EOF' "${TMP_11_CRON_HALF_MONTHLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_11_CRON_HALF_MONTHLY}" ]]; then
    ss_wget "${TMP_11_CRON_HALF_MONTHLY}" "${GITLAB_11_CRON_HALF_MONTHLY}"
fi
VALIDATE2_TMP_11_CRON_HALF_MONTHLY=$(grep 'SS_EOF' "${TMP_11_CRON_HALF_MONTHLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_11_CRON_HALF_MONTHLY}" ]]; then
    ss_wget "${TMP_11_CRON_HALF_MONTHLY}" "${SOURCEFORGE_11_CRON_HALF_MONTHLY}"
fi

## 12-cron-monthly ##
ss_wget "${TMP_12_CRON_MONTHLY}" "${GITHUB_12_CRON_MONTHLY}"
VALIDATE_TMP_12_CRON_MONTHLY=$(grep 'SS_EOF' "${TMP_12_CRON_MONTHLY}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_12_CRON_MONTHLY}" ]]; then
    ss_wget "${TMP_12_CRON_MONTHLY}" "${GITLAB_12_CRON_MONTHLY}"
fi
VALIDATE2_TMP_12_CRON_MONTHLY=$(grep 'SS_EOF' "${TMP_12_CRON_MONTHLY}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_12_CRON_MONTHLY}" ]]; then
    ss_wget "${TMP_12_CRON_MONTHLY}" "${SOURCEFORGE_12_CRON_MONTHLY}"
fi

## 13-cron-sometimes ##
ss_wget "${TMP_13_CRON_SOMETIMES}" "${GITHUB_13_CRON_SOMETIMES}"
VALIDATE_TMP_13_CRON_SOMETIMES=$(grep 'SS_EOF' "${TMP_13_CRON_SOMETIMES}" 2> /dev/null)
if [[ -z "${VALIDATE_TMP_13_CRON_SOMETIMES}" ]]; then
    ss_wget "${TMP_13_CRON_SOMETIMES}" "${GITLAB_13_CRON_SOMETIMES}"
fi
VALIDATE2_TMP_13_CRON_SOMETIMES=$(grep 'SS_EOF' "${TMP_13_CRON_SOMETIMES}" 2> /dev/null)
if [[ -z "${VALIDATE2_TMP_13_CRON_SOMETIMES}" ]]; then
    ss_wget "${TMP_13_CRON_SOMETIMES}" "${SOURCEFORGE_13_CRON_SOMETIMES}"
fi

####################################################################################################
#### D. SS-Check: Retrieve Custom Cron Job Boilerplates (If Not Exist) #############################
####################################################################################################

## this will retrieve and install boilerplates for custom cron jobs if none are found ##
## you can then edit these files as needed and they will not be overwritten ##

if [[ ! -f "${PATH_01_CRON_OFTEN_CUSTOM}" ]]; then
    ss_wget "${TMP_01_CRON_OFTEN_CUSTOM}" "${GITHUB_01_CRON_OFTEN_CUSTOM}"
    ss_cp_if_not_exists "${TMP_01_CRON_OFTEN_CUSTOM}" "${PATH_01_CRON_OFTEN_CUSTOM}"
fi

if [[ ! -f "${PATH_02_CRON_REGULAR_CUSTOM}" ]]; then
    ss_wget "${TMP_02_CRON_REGULAR_CUSTOM}" "${GITHUB_02_CRON_REGULAR_CUSTOM}"
    ss_cp_if_not_exists "${TMP_02_CRON_REGULAR_CUSTOM}" "${PATH_02_CRON_REGULAR_CUSTOM}"
fi

if [[ ! -f "${PATH_03_CRON_QUARTER_HOURLY_CUSTOM}" ]]; then
    ss_wget "${TMP_03_CRON_QUARTER_HOURLY_CUSTOM}" "${GITHUB_03_CRON_QUARTER_HOURLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_03_CRON_QUARTER_HOURLY_CUSTOM}" "${PATH_03_CRON_QUARTER_HOURLY_CUSTOM}"
fi

if [[ ! -f "${PATH_04_CRON_HALF_HOURLY_CUSTOM}" ]]; then
    ss_wget "${TMP_04_CRON_HALF_HOURLY_CUSTOM}" "${GITHUB_04_CRON_HALF_HOURLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_04_CRON_HALF_HOURLY_CUSTOM}" "${PATH_04_CRON_HALF_HOURLY_CUSTOM}"
fi

if [[ ! -f "${PATH_05_CRON_HOURLY_CUSTOM}" ]]; then
    ss_wget "${TMP_05_CRON_HOURLY_CUSTOM}" "${GITHUB_05_CRON_HOURLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_05_CRON_HOURLY_CUSTOM}" "${PATH_05_CRON_HOURLY_CUSTOM}"
fi

if [[ ! -f "${PATH_06_CRON_QUARTER_DAILY_CUSTOM}" ]]; then
    ss_wget "${TMP_06_CRON_QUARTER_DAILY_CUSTOM}" "${GITHUB_06_CRON_QUARTER_DAILY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_06_CRON_QUARTER_DAILY_CUSTOM}" "${PATH_06_CRON_QUARTER_DAILY_CUSTOM}"
fi

if [[ ! -f "${PATH_07_CRON_HALF_DAILY_CUSTOM}" ]]; then
    ss_wget "${TMP_07_CRON_HALF_DAILY_CUSTOM}" "${GITHUB_07_CRON_HALF_DAILY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_07_CRON_HALF_DAILY_CUSTOM}" "${PATH_07_CRON_HALF_DAILY_CUSTOM}"
fi

if [[ ! -f "${PATH_08_CRON_DAILY_CUSTOM}" ]]; then
    ss_wget "${TMP_08_CRON_DAILY_CUSTOM}" "${GITHUB_08_CRON_DAILY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_08_CRON_DAILY_CUSTOM}" "${PATH_08_CRON_DAILY_CUSTOM}"
fi

if [[ ! -f "${PATH_09_CRON_HALF_WEEKLY_CUSTOM}" ]]; then
    ss_wget "${TMP_09_CRON_HALF_WEEKLY_CUSTOM}" "${GITHUB_09_CRON_HALF_WEEKLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_09_CRON_HALF_WEEKLY_CUSTOM}" "${PATH_09_CRON_HALF_WEEKLY_CUSTOM}"
fi

if [[ ! -f "${PATH_10_CRON_WEEKLY_CUSTOM}" ]]; then
    ss_wget "${TMP_10_CRON_WEEKLY_CUSTOM}" "${GITHUB_10_CRON_WEEKLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_10_CRON_WEEKLY_CUSTOM}" "${PATH_10_CRON_WEEKLY_CUSTOM}"
fi

if [[ ! -f "${PATH_11_CRON_HALF_MONTHLY_CUSTOM}" ]]; then
    ss_wget "${TMP_11_CRON_HALF_MONTHLY_CUSTOM}" "${GITHUB_11_CRON_HALF_MONTHLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_11_CRON_HALF_MONTHLY_CUSTOM}" "${PATH_11_CRON_HALF_MONTHLY_CUSTOM}"
fi

if [[ ! -f "${PATH_12_CRON_MONTHLY_CUSTOM}" ]]; then
    ss_wget "${TMP_12_CRON_MONTHLY_CUSTOM}" "${GITHUB_12_CRON_MONTHLY_CUSTOM}"
    ss_cp_if_not_exists "${TMP_12_CRON_MONTHLY_CUSTOM}" "${PATH_12_CRON_MONTHLY_CUSTOM}"
fi

if [[ ! -f "${PATH_13_CRON_SOMETIMES_CUSTOM}" ]]; then
    ss_wget "${TMP_13_CRON_SOMETIMES_CUSTOM}" "${GITHUB_13_CRON_SOMETIMES_CUSTOM}"
    ss_cp_if_not_exists "${TMP_13_CRON_SOMETIMES_CUSTOM}" "${PATH_13_CRON_SOMETIMES_CUSTOM}"
fi

####################################################################################################
#### E. SS-Check: Retrieve Bash Scripts (Except SS-Check) ##########################################
####################################################################################################

## here we retrieve all the latest ss core cron jobs and bash scripts to keep them updated ##
## this process does not affect ss-config or LEMP modules, nor the ss-check file ##

## ss-clean-database ##
ss_wget "$TMP_SS_CLEAN_DATABASE" "$MIRROR_SS_CLEAN_DATABASE"
VALIDATE_TMP_SS_CLEAN_DATABASE=$(grep 'SS_EOF' "${TMP_SS_CLEAN_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_CLEAN_DATABASE" ]]; then
    ss_wget "$TMP_SS_CLEAN_DATABASE" "$MIRROR2_SS_CLEAN_DATABASE"
fi

## ss-clean-files ##
ss_wget "$TMP_SS_CLEAN_FILES" "$MIRROR_SS_CLEAN_FILES"
VALIDATE_TMP_SS_CLEAN_FILES=$(grep 'SS_EOF' "${TMP_SS_CLEAN_FILES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_CLEAN_FILES" ]]; then
    ss_wget "$TMP_SS_CLEAN_FILES" "$MIRROR2_SS_CLEAN_FILES"
fi

## ss-config-sample ##
ss_wget "$TMP_SS_CONFIG_SAMPLE" "$MIRROR_SS_CONFIG_SAMPLE"
VALIDATE_TMP_SS_CONFIG_SAMPLE=$(grep 'SS_EOF' "${TMP_SS_CONFIG_SAMPLE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_CONFIG_SAMPLE" ]]; then
    ss_wget "$TMP_SS_CONFIG_SAMPLE" "$MIRROR2_SS_CONFIG_SAMPLE"
fi

## ss-delete-database ##
ss_wget "$TMP_SS_DELETE_DATABASE" "$MIRROR_SS_DELETE_DATABASE"
VALIDATE_TMP_SS_DELETE_DATABASE=$(grep 'SS_EOF' "${TMP_SS_DELETE_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_DELETE_DATABASE" ]]; then
    ss_wget "$TMP_SS_DELETE_DATABASE" "$MIRROR2_SS_DELETE_DATABASE"
fi

## ss-delete-files ##
ss_wget "$TMP_SS_DELETE_FILES" "$MIRROR_SS_DELETE_FILES"
VALIDATE_TMP_SS_DELETE_FILES=$(grep 'SS_EOF' "${TMP_SS_DELETE_FILES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_DELETE_FILES" ]]; then
    ss_wget "$TMP_SS_DELETE_FILES" "$MIRROR2_SS_DELETE_FILES"
fi

## ss-dump-database ##
ss_wget "$TMP_SS_DUMP_DATABASE" "$MIRROR_SS_DUMP_DATABASE"
VALIDATE_TMP_SS_DUMP_DATABASE=$(grep 'SS_EOF' "${TMP_SS_DUMP_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_DUMP_DATABASE" ]]; then
    ss_wget "$TMP_SS_DUMP_DATABASE" "$MIRROR2_SS_DUMP_DATABASE"
fi

## ss-dump-files ##
ss_wget "$TMP_SS_DUMP_FILES" "$MIRROR_SS_DUMP_FILES"
VALIDATE_TMP_SS_DUMP_FILES=$(grep 'SS_EOF' "${TMP_SS_DUMP_FILES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_DUMP_FILES" ]]; then
    ss_wget "$TMP_SS_DUMP_FILES" "$MIRROR2_SS_DUMP_FILES"
fi

## ss-empty-logs ##
ss_wget "$TMP_SS_EMPTY_LOGS" "$MIRROR_SS_EMPTY_LOGS"
VALIDATE_TMP_SS_EMPTY_LOGS=$(grep 'SS_EOF' "${TMP_SS_EMPTY_LOGS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_EMPTY_LOGS" ]]; then
    ss_wget "$TMP_SS_EMPTY_LOGS" "$MIRROR2_SS_EMPTY_LOGS"
fi

## ss-encrypt-acme ##
ss_wget "$TMP_SS_ENCRYPT_ACME" "$MIRROR_SS_ENCRYPT_ACME"
VALIDATE_TMP_SS_ENCRYPT_ACME=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_ACME}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_ENCRYPT_ACME" ]]; then
    ss_wget "$TMP_SS_ENCRYPT_ACME" "$MIRROR2_SS_ENCRYPT_ACME"
fi

## ss-encrypt-certbot ##
ss_wget "$TMP_SS_ENCRYPT_CERTBOT" "$MIRROR_SS_ENCRYPT_CERTBOT"
VALIDATE_TMP_SS_ENCRYPT_CERTBOT=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_CERTBOT}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_ENCRYPT_CERTBOT" ]]; then
    ss_wget "$TMP_SS_ENCRYPT_CERTBOT" "$MIRROR2_SS_ENCRYPT_CERTBOT"
fi

## ss-encrypt-openssl ##
ss_wget "$TMP_SS_ENCRYPT_OPENSSL" "$MIRROR_SS_ENCRYPT_OPENSSL"
VALIDATE_TMP_SS_ENCRYPT_OPENSSL=$(grep 'SS_EOF' "${TMP_SS_ENCRYPT_OPENSSL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_ENCRYPT_OPENSSL" ]]; then
    ss_wget "$TMP_SS_ENCRYPT_OPENSSL" "$MIRROR2_SS_ENCRYPT_OPENSSL"
fi

## ss-functions ##
ss_wget "$TMP_SS_FUNCTIONS" "$MIRROR_SS_FUNCTIONS"
VALIDATE_TMP_SS_FUNCTIONS=$(grep 'SS_EOF' "${TMP_SS_FUNCTIONS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_FUNCTIONS" ]]; then
    ss_wget "$TMP_SS_FUNCTIONS" "$MIRROR2_SS_FUNCTIONS"
fi

## ss-import-database ##
ss_wget "$TMP_SS_IMPORT_DATABASE" "$MIRROR_SS_IMPORT_DATABASE"
VALIDATE_TMP_SS_IMPORT_DATABASE=$(grep 'SS_EOF' "${TMP_SS_IMPORT_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_IMPORT_DATABASE" ]]; then
    ss_wget "$TMP_SS_IMPORT_DATABASE" "$MIRROR2_SS_IMPORT_DATABASE"
fi

## ss-import-files ##
ss_wget "$TMP_SS_IMPORT_FILES" "$MIRROR_SS_IMPORT_FILES"
VALIDATE_TMP_SS_IMPORT_FILES=$(grep 'SS_EOF' "${TMP_SS_IMPORT_FILES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_IMPORT_FILES" ]]; then
    ss_wget "$TMP_SS_IMPORT_FILES" "$MIRROR2_SS_IMPORT_FILES"
fi

## ss-install ##
ss_wget "$TMP_SS_INSTALL" "$MIRROR_SS_INSTALL"
VALIDATE_TMP_SS_INSTALL=$(grep 'SS_EOF' "${TMP_SS_INSTALL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL" ]]; then
    ss_wget "$TMP_SS_INSTALL" "$MIRROR2_SS_INSTALL"
fi

## ss-install-adminer ##
ss_wget "$TMP_SS_INSTALL_ADMINER" "$MIRROR_SS_INSTALL_ADMINER"
VALIDATE_TMP_SS_INSTALL_ADMINER=$(grep 'SS_EOF' "${TMP_SS_INSTALL_ADMINER}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_ADMINER" ]]; then
    ss_wget "$TMP_SS_INSTALL_ADMINER" "$MIRROR2_SS_INSTALL_ADMINER"
fi

## ss-install-clamav ##
ss_wget "$TMP_SS_INSTALL_CLAMAV" "$MIRROR_SS_INSTALL_CLAMAV"
VALIDATE_TMP_SS_INSTALL_CLAMAV=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CLAMAV}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_CLAMAV" ]]; then
    ss_wget "$TMP_SS_INSTALL_CLAMAV" "$MIRROR2_SS_INSTALL_CLAMAV"
fi

## ss-install-craft-config ##
ss_wget "$TMP_SS_INSTALL_CRAFT_CONFIG" "$MIRROR_SS_INSTALL_CRAFT_CONFIG"
VALIDATE_TMP_SS_INSTALL_CRAFT_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CRAFT_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_CRAFT_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_CRAFT_CONFIG" "$MIRROR2_SS_INSTALL_CRAFT_CONFIG"
fi

## ss-install-craft-core ##
ss_wget "$TMP_SS_INSTALL_CRAFT_CORE" "$MIRROR_SS_INSTALL_CRAFT_CORE"
VALIDATE_TMP_SS_INSTALL_CRAFT_CORE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_CRAFT_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_CRAFT_CORE" ]]; then
    ss_wget "$TMP_SS_INSTALL_CRAFT_CORE" "$MIRROR2_SS_INSTALL_CRAFT_CORE"
fi

## ss-install-mediawiki-config ##
ss_wget "$TMP_SS_INSTALL_MEDIAWIKI_CONFIG" "$MIRROR_SS_INSTALL_MEDIAWIKI_CONFIG"
VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_MEDIAWIKI_CONFIG" "$MIRROR2_SS_INSTALL_MEDIAWIKI_CONFIG"
fi

## ss-install-mediawiki-core ##
ss_wget "$TMP_SS_INSTALL_MEDIAWIKI_CORE" "$MIRROR_SS_INSTALL_MEDIAWIKI_CORE"
VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_CORE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MEDIAWIKI_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MEDIAWIKI_CORE" ]]; then
    ss_wget "$TMP_SS_INSTALL_MEDIAWIKI_CORE" "$MIRROR2_SS_INSTALL_MEDIAWIKI_CORE"
fi

## ss-install-moodle-config ##
ss_wget "$TMP_SS_INSTALL_MOODLE_CONFIG" "$MIRROR_SS_INSTALL_MOODLE_CONFIG"
VALIDATE_TMP_SS_INSTALL_MOODLE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MOODLE_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MOODLE_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_MOODLE_CONFIG" "$MIRROR2_SS_INSTALL_MOODLE_CONFIG"
fi

## ss-install-moodle-core ##
ss_wget "$TMP_SS_INSTALL_MOODLE_CORE" "$MIRROR_SS_INSTALL_MOODLE_CORE"
VALIDATE_TMP_SS_INSTALL_MOODLE_CORE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MOODLE_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MOODLE_CORE" ]]; then
    ss_wget "$TMP_SS_INSTALL_MOODLE_CORE" "$MIRROR2_SS_INSTALL_MOODLE_CORE"
fi

## ss-install-mysql-config ##
ss_wget "$TMP_SS_INSTALL_MYSQL_CONFIG" "$MIRROR_SS_INSTALL_MYSQL_CONFIG"
VALIDATE_TMP_SS_INSTALL_MYSQL_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MYSQL_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_MYSQL_CONFIG" "$MIRROR2_SS_INSTALL_MYSQL_CONFIG"
fi

## ss-install-mysql-database ##
ss_wget "$TMP_SS_INSTALL_MYSQL_DATABASE" "$MIRROR_SS_INSTALL_MYSQL_DATABASE"
VALIDATE_TMP_SS_INSTALL_MYSQL_DATABASE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MYSQL_DATABASE" ]]; then
    ss_wget "$TMP_SS_INSTALL_MYSQL_DATABASE" "$MIRROR2_SS_INSTALL_MYSQL_DATABASE"
fi

## ss-install-mysql-packages ##
ss_wget "$TMP_SS_INSTALL_MYSQL_PACKAGES" "$MIRROR_SS_INSTALL_MYSQL_PACKAGES"
VALIDATE_TMP_SS_INSTALL_MYSQL_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_MYSQL_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_MYSQL_PACKAGES" ]]; then
    ss_wget "$TMP_SS_INSTALL_MYSQL_PACKAGES" "$MIRROR2_SS_INSTALL_MYSQL_PACKAGES"
fi

## ss-install-nginx-config ##
ss_wget "$TMP_SS_INSTALL_NGINX_CONFIG" "$MIRROR_SS_INSTALL_NGINX_CONFIG"
VALIDATE_TMP_SS_INSTALL_NGINX_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_NGINX_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_NGINX_CONFIG" "$MIRROR2_SS_INSTALL_NGINX_CONFIG"
fi

## ss-install-nginx-letsencrypt ##
ss_wget "$TMP_SS_INSTALL_NGINX_LETSENCRYPT" "$MIRROR_SS_INSTALL_NGINX_LETSENCRYPT"
VALIDATE_TMP_SS_INSTALL_NGINX_LETSENCRYPT=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_NGINX_LETSENCRYPT" ]]; then
    ss_wget "$TMP_SS_INSTALL_NGINX_LETSENCRYPT" "$MIRROR2_SS_INSTALL_NGINX_LETSENCRYPT"
fi

## ss-install-nginx-openssl ##
ss_wget "$TMP_SS_INSTALL_NGINX_OPENSSL" "$MIRROR_SS_INSTALL_NGINX_OPENSSL"
VALIDATE_TMP_SS_INSTALL_NGINX_OPENSSL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_OPENSSL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_NGINX_OPENSSL" ]]; then
    ss_wget "$TMP_SS_INSTALL_NGINX_OPENSSL" "$MIRROR2_SS_INSTALL_NGINX_OPENSSL"
fi

## ss-install-nginx-packages ##
ss_wget "$TMP_SS_INSTALL_NGINX_PACKAGES" "$MIRROR_SS_INSTALL_NGINX_PACKAGES"
VALIDATE_TMP_SS_INSTALL_NGINX_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_NGINX_PACKAGES" ]]; then
    ss_wget "$TMP_SS_INSTALL_NGINX_PACKAGES" "$MIRROR2_SS_INSTALL_NGINX_PACKAGES"
fi

## ss-install-nginx-ssl ##
ss_wget "$TMP_SS_INSTALL_NGINX_SSL" "$MIRROR_SS_INSTALL_NGINX_SSL"
VALIDATE_TMP_SS_INSTALL_NGINX_SSL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_NGINX_SSL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_NGINX_SSL" ]]; then
    ss_wget "$TMP_SS_INSTALL_NGINX_SSL" "$MIRROR2_SS_INSTALL_NGINX_SSL"
fi

## ss-install-opencart-config ##
ss_wget "$TMP_SS_INSTALL_OPENCART_CONFIG" "$MIRROR_SS_INSTALL_OPENCART_CONFIG"
VALIDATE_TMP_SS_INSTALL_OPENCART_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_OPENCART_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_OPENCART_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_OPENCART_CONFIG" "$MIRROR2_SS_INSTALL_OPENCART_CONFIG"
fi

## ss-install-opencart-core ##
ss_wget "$TMP_SS_INSTALL_OPENCART_CORE" "$MIRROR_SS_INSTALL_OPENCART_CORE"
VALIDATE_TMP_SS_INSTALL_OPENCART_CORE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_OPENCART_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_OPENCART_CORE" ]]; then
    ss_wget "$TMP_SS_INSTALL_OPENCART_CORE" "$MIRROR2_SS_INSTALL_OPENCART_CORE"
fi

## ss-install-php-config ##
ss_wget "$TMP_SS_INSTALL_PHP_CONFIG" "$MIRROR_SS_INSTALL_PHP_CONFIG"
VALIDATE_TMP_SS_INSTALL_PHP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PHP_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_PHP_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_PHP_CONFIG" "$MIRROR2_SS_INSTALL_PHP_CONFIG"
fi

## ss-install-php-packages ##
ss_wget "$TMP_SS_INSTALL_PHP_PACKAGES" "$MIRROR_SS_INSTALL_PHP_PACKAGES"
VALIDATE_TMP_SS_INSTALL_PHP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PHP_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_PHP_PACKAGES" ]]; then
    ss_wget "$TMP_SS_INSTALL_PHP_PACKAGES" "$MIRROR2_SS_INSTALL_PHP_PACKAGES"
fi

## ss-install-prestashop-config ##
ss_wget "$TMP_SS_INSTALL_PRESTASHOP_CONFIG" "$MIRROR_SS_INSTALL_PRESTASHOP_CONFIG"
VALIDATE_TMP_SS_INSTALL_PRESTASHOP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_PRESTASHOP_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_PRESTASHOP_CONFIG" "$MIRROR2_SS_INSTALL_PRESTASHOP_CONFIG"
fi

## ss-install-prestashop-core ##
ss_wget "$TMP_SS_INSTALL_PRESTASHOP_CORE" "$MIRROR_SS_INSTALL_PRESTASHOP_CORE"
VALIDATE_TMP_SS_INSTALL_PRESTASHOP_CORE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_PRESTASHOP_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_PRESTASHOP_CORE" ]]; then
    ss_wget "$TMP_SS_INSTALL_PRESTASHOP_CORE" "$MIRROR2_SS_INSTALL_PRESTASHOP_CORE"
fi

## ss-install-rclone-config ##
ss_wget "$TMP_SS_INSTALL_RCLONE_CONFIG" "$MIRROR_SS_INSTALL_RCLONE_CONFIG"
VALIDATE_TMP_SS_INSTALL_RCLONE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_RCLONE_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_RCLONE_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_RCLONE_CONFIG" "$MIRROR2_SS_INSTALL_RCLONE_CONFIG"
fi

## ss-install-rclone-packages ##
ss_wget "$TMP_SS_INSTALL_RCLONE_PACKAGES" "$MIRROR_SS_INSTALL_RCLONE_PACKAGES"
VALIDATE_TMP_SS_INSTALL_RCLONE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_RCLONE_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_RCLONE_PACKAGES" ]]; then
    ss_wget "$TMP_SS_INSTALL_RCLONE_PACKAGES" "$MIRROR2_SS_INSTALL_RCLONE_PACKAGES"
fi

## ss-install-redis-config ##
ss_wget "$TMP_SS_INSTALL_REDIS_CONFIG" "$MIRROR_SS_INSTALL_REDIS_CONFIG"
VALIDATE_TMP_SS_INSTALL_REDIS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_REDIS_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_REDIS_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_REDIS_CONFIG" "$MIRROR2_SS_INSTALL_REDIS_CONFIG"
fi

## ss-install-redis-packages ##
ss_wget "$TMP_SS_INSTALL_REDIS_PACKAGES" "$MIRROR_SS_INSTALL_REDIS_PACKAGES"
VALIDATE_TMP_SS_INSTALL_REDIS_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_REDIS_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_REDIS_PACKAGES" ]]; then
    ss_wget "$TMP_SS_INSTALL_REDIS_PACKAGES" "$MIRROR2_SS_INSTALL_REDIS_PACKAGES"
fi

## ss-install-ubuntu-bash ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_BASH" "$MIRROR_SS_INSTALL_UBUNTU_BASH"
VALIDATE_TMP_SS_INSTALL_UBUNTU_BASH=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_BASH}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_BASH" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_BASH" "$MIRROR2_SS_INSTALL_UBUNTU_BASH"
fi

## ss-install-ubuntu-crontab ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_CRONTAB" "$MIRROR_SS_INSTALL_UBUNTU_CRONTAB"
VALIDATE_TMP_SS_INSTALL_UBUNTU_CRONTAB=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_CRONTAB" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_CRONTAB" "$MIRROR2_SS_INSTALL_UBUNTU_CRONTAB"
fi

## ss-install-ubuntu-kernel ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_KERNEL" "$MIRROR_SS_INSTALL_UBUNTU_KERNEL"
VALIDATE_TMP_SS_INSTALL_UBUNTU_KERNEL=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_KERNEL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_KERNEL" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_KERNEL" "$MIRROR2_SS_INSTALL_UBUNTU_KERNEL"
fi

## ss-install-ubuntu-ssh ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_SSH" "$MIRROR_SS_INSTALL_UBUNTU_SSH"
VALIDATE_TMP_SS_INSTALL_UBUNTU_SSH=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_SSH}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_SSH" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_SSH" "$MIRROR2_SS_INSTALL_UBUNTU_SSH"
fi

## ss-install-ubuntu-swapfile ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_SWAPFILE" "$MIRROR_SS_INSTALL_UBUNTU_SWAPFILE"
VALIDATE_TMP_SS_INSTALL_UBUNTU_SWAPFILE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_SWAPFILE" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_SWAPFILE" "$MIRROR2_SS_INSTALL_UBUNTU_SWAPFILE"
fi

## ss-install-ubuntu-users ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_USERS" "$MIRROR_SS_INSTALL_UBUNTU_USERS"
VALIDATE_TMP_SS_INSTALL_UBUNTU_USERS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_USERS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_USERS" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_USERS" "$MIRROR2_SS_INSTALL_UBUNTU_USERS"
fi

## ss-install-ubuntu-utils ##
ss_wget "$TMP_SS_INSTALL_UBUNTU_UTILS" "$MIRROR_SS_INSTALL_UBUNTU_UTILS"
VALIDATE_TMP_SS_INSTALL_UBUNTU_UTILS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UBUNTU_UTILS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UBUNTU_UTILS" ]]; then
    ss_wget "$TMP_SS_INSTALL_UBUNTU_UTILS" "$MIRROR2_SS_INSTALL_UBUNTU_UTILS"
fi

## ss-install-ufw-config ##
ss_wget "$TMP_SS_INSTALL_UFW_CONFIG" "$MIRROR_SS_INSTALL_UFW_CONFIG"
VALIDATE_TMP_SS_INSTALL_UFW_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UFW_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UFW_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_UFW_CONFIG" "$MIRROR2_SS_INSTALL_UFW_CONFIG"
fi

## ss-install-ufw-packages ##
ss_wget "$TMP_SS_INSTALL_UFW_PACKAGES" "$MIRROR_SS_INSTALL_UFW_PACKAGES"
VALIDATE_TMP_SS_INSTALL_UFW_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_INSTALL_UFW_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_UFW_PACKAGES" ]]; then
    ss_wget "$TMP_SS_INSTALL_UFW_PACKAGES" "$MIRROR2_SS_INSTALL_UFW_PACKAGES"
fi

## ss-install-wordpress-cli ##
ss_wget "$TMP_SS_INSTALL_WORDPRESS_CLI" "$MIRROR_SS_INSTALL_WORDPRESS_CLI"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_CLI=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CLI}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_WORDPRESS_CLI" ]]; then
    ss_wget "$TMP_SS_INSTALL_WORDPRESS_CLI" "$MIRROR2_SS_INSTALL_WORDPRESS_CLI"
fi

## ss-install-wordpress-config ##
ss_wget "$TMP_SS_INSTALL_WORDPRESS_CONFIG" "$MIRROR_SS_INSTALL_WORDPRESS_CONFIG"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_WORDPRESS_CONFIG" ]]; then
    ss_wget "$TMP_SS_INSTALL_WORDPRESS_CONFIG" "$MIRROR2_SS_INSTALL_WORDPRESS_CONFIG"
fi

## ss-install-wordpress-core ##
ss_wget "$TMP_SS_INSTALL_WORDPRESS_CORE" "$MIRROR_SS_INSTALL_WORDPRESS_CORE"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_CORE=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_WORDPRESS_CORE" ]]; then
    ss_wget "$TMP_SS_INSTALL_WORDPRESS_CORE" "$MIRROR2_SS_INSTALL_WORDPRESS_CORE"
fi

## ss-install-wordpress-mu-plugins ##
ss_wget "$TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS" "$MIRROR_SS_INSTALL_WORDPRESS_MU_PLUGINS"
VALIDATE_TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS=$(grep 'SS_EOF' "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS" ]]; then
    ss_wget "$TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS" "$MIRROR2_SS_INSTALL_WORDPRESS_MU_PLUGINS"
fi

## ss-maintenance-disable ##
ss_wget "$TMP_SS_MAINTENANCE_DISABLE" "$MIRROR_SS_MAINTENANCE_DISABLE"
VALIDATE_TMP_SS_MAINTENANCE_DISABLE=$(grep 'SS_EOF' "${TMP_SS_MAINTENANCE_DISABLE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_MAINTENANCE_DISABLE" ]]; then
    ss_wget "$TMP_SS_MAINTENANCE_DISABLE" "$MIRROR2_SS_MAINTENANCE_DISABLE"
fi

## ss-maintenance-enable ##
ss_wget "$TMP_SS_MAINTENANCE_ENABLE" "$MIRROR_SS_MAINTENANCE_ENABLE"
VALIDATE_TMP_SS_MAINTENANCE_ENABLE=$(grep 'SS_EOF' "${TMP_SS_MAINTENANCE_ENABLE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_MAINTENANCE_ENABLE" ]]; then
    ss_wget "$TMP_SS_MAINTENANCE_ENABLE" "$MIRROR2_SS_MAINTENANCE_ENABLE"
fi

## ss-monitor-resources ##
ss_wget "$TMP_SS_MONITOR_RESOURCES" "$MIRROR_SS_MONITOR_RESOURCES"
VALIDATE_TMP_SS_MONITOR_RESOURCES=$(grep 'SS_EOF' "${TMP_SS_MONITOR_RESOURCES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_MONITOR_RESOURCES" ]]; then
    ss_wget "$TMP_SS_MONITOR_RESOURCES" "$MIRROR2_SS_MONITOR_RESOURCES"
fi

## ss-optimize-database ##
ss_wget "$TMP_SS_OPTIMIZE_DATABASE" "$MIRROR_SS_OPTIMIZE_DATABASE"
VALIDATE_TMP_SS_OPTIMIZE_DATABASE=$(grep 'SS_EOF' "${TMP_SS_OPTIMIZE_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_OPTIMIZE_DATABASE" ]]; then
    ss_wget "$TMP_SS_OPTIMIZE_DATABASE" "$MIRROR2_SS_OPTIMIZE_DATABASE"
fi

## ss-optimize-files ##
ss_wget "$TMP_SS_OPTIMIZE_FILES" "$MIRROR_SS_OPTIMIZE_FILES"
VALIDATE_TMP_SS_OPTIMIZE_FILES=$(grep 'SS_EOF' "${TMP_SS_OPTIMIZE_FILES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_OPTIMIZE_FILES" ]]; then
    ss_wget "$TMP_SS_OPTIMIZE_FILES" "$MIRROR2_SS_OPTIMIZE_FILES"
fi

## ss-perms ##
ss_wget "$TMP_SS_PERMS" "$MIRROR_SS_PERMS"
VALIDATE_TMP_SS_PERMS=$(grep 'SS_EOF' "${TMP_SS_PERMS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS" ]]; then
    ss_wget "$TMP_SS_PERMS" "$MIRROR2_SS_PERMS"
fi

## ss-perms-adminer ##
ss_wget "$TMP_SS_PERMS_ADMINER" "$MIRROR_SS_PERMS_ADMINER"
VALIDATE_TMP_SS_PERMS_ADMINER=$(grep 'SS_EOF' "${TMP_SS_PERMS_ADMINER}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_ADMINER" ]]; then
    ss_wget "$TMP_SS_PERMS_ADMINER" "$MIRROR2_SS_PERMS_ADMINER"
fi

## ss-perms-clamav ##
ss_wget "$TMP_SS_PERMS_CLAMAV" "$MIRROR_SS_PERMS_CLAMAV"
VALIDATE_TMP_SS_PERMS_CLAMAV=$(grep 'SS_EOF' "${TMP_SS_PERMS_CLAMAV}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_CLAMAV" ]]; then
    ss_wget "$TMP_SS_PERMS_CLAMAV" "$MIRROR2_SS_PERMS_CLAMAV"
fi

## ss-perms-craft-config ##
ss_wget "$TMP_SS_PERMS_CRAFT_CONFIG" "$MIRROR_SS_PERMS_CRAFT_CONFIG"
VALIDATE_TMP_SS_PERMS_CRAFT_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_CRAFT_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_CRAFT_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_CRAFT_CONFIG" "$MIRROR2_SS_PERMS_CRAFT_CONFIG"
fi

## ss-perms-craft-core ##
ss_wget "$TMP_SS_PERMS_CRAFT_CORE" "$MIRROR_SS_PERMS_CRAFT_CORE"
VALIDATE_TMP_SS_PERMS_CRAFT_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_CRAFT_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_CRAFT_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_CRAFT_CORE" "$MIRROR2_SS_PERMS_CRAFT_CORE"
fi

## ss-perms-magento-config ##
ss_wget "$TMP_SS_PERMS_MAGENTO_CONFIG" "$MIRROR_SS_PERMS_MAGENTO_CONFIG"
VALIDATE_TMP_SS_PERMS_MAGENTO_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MAGENTO_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MAGENTO_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_MAGENTO_CONFIG" "$MIRROR2_SS_PERMS_MAGENTO_CONFIG"
fi

## ss-perms-magento-core ##
ss_wget "$TMP_SS_PERMS_MAGENTO_CORE" "$MIRROR_SS_PERMS_MAGENTO_CORE"
VALIDATE_TMP_SS_PERMS_MAGENTO_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_MAGENTO_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MAGENTO_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_MAGENTO_CORE" "$MIRROR2_SS_PERMS_MAGENTO_CORE"
fi

## ss-perms-mediawiki-config ##
ss_wget "$TMP_SS_PERMS_MEDIAWIKI_CONFIG" "$MIRROR_SS_PERMS_MEDIAWIKI_CONFIG"
VALIDATE_TMP_SS_PERMS_MEDIAWIKI_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MEDIAWIKI_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_MEDIAWIKI_CONFIG" "$MIRROR2_SS_PERMS_MEDIAWIKI_CONFIG"
fi

## ss-perms-mediawiki-core ##
ss_wget "$TMP_SS_PERMS_MEDIAWIKI_CORE" "$MIRROR_SS_PERMS_MEDIAWIKI_CORE"
VALIDATE_TMP_SS_PERMS_MEDIAWIKI_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_MEDIAWIKI_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MEDIAWIKI_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_MEDIAWIKI_CORE" "$MIRROR2_SS_PERMS_MEDIAWIKI_CORE"
fi

## ss-perms-moodle-config ##
ss_wget "$TMP_SS_PERMS_MOODLE_CONFIG" "$MIRROR_SS_PERMS_MOODLE_CONFIG"
VALIDATE_TMP_SS_PERMS_MOODLE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MOODLE_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MOODLE_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_MOODLE_CONFIG" "$MIRROR2_SS_PERMS_MOODLE_CONFIG"
fi

## ss-perms-moodle-core ##
ss_wget "$TMP_SS_PERMS_MOODLE_CORE" "$MIRROR_SS_PERMS_MOODLE_CORE"
VALIDATE_TMP_SS_PERMS_MOODLE_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_MOODLE_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MOODLE_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_MOODLE_CORE" "$MIRROR2_SS_PERMS_MOODLE_CORE"
fi

## ss-perms-mysql-config ##
ss_wget "$TMP_SS_PERMS_MYSQL_CONFIG" "$MIRROR_SS_PERMS_MYSQL_CONFIG"
VALIDATE_TMP_SS_PERMS_MYSQL_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MYSQL_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_MYSQL_CONFIG" "$MIRROR2_SS_PERMS_MYSQL_CONFIG"
fi

## ss-perms-mysql-database ##
ss_wget "$TMP_SS_PERMS_MYSQL_DATABASE" "$MIRROR_SS_PERMS_MYSQL_DATABASE"
VALIDATE_TMP_SS_PERMS_MYSQL_DATABASE=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_DATABASE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MYSQL_DATABASE" ]]; then
    ss_wget "$TMP_SS_PERMS_MYSQL_DATABASE" "$MIRROR2_SS_PERMS_MYSQL_DATABASE"
fi

## ss-perms-mysql-packages ##
ss_wget "$TMP_SS_PERMS_MYSQL_PACKAGES" "$MIRROR_SS_PERMS_MYSQL_PACKAGES"
VALIDATE_TMP_SS_PERMS_MYSQL_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_MYSQL_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_MYSQL_PACKAGES" ]]; then
    ss_wget "$TMP_SS_PERMS_MYSQL_PACKAGES" "$MIRROR2_SS_PERMS_MYSQL_PACKAGES"
fi

## ss-perms-nginx-config ##
ss_wget "$TMP_SS_PERMS_NGINX_CONFIG" "$MIRROR_SS_PERMS_NGINX_CONFIG"
VALIDATE_TMP_SS_PERMS_NGINX_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_NGINX_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_NGINX_CONFIG" "$MIRROR2_SS_PERMS_NGINX_CONFIG"
fi

## ss-perms-nginx-packages ##
ss_wget "$TMP_SS_PERMS_NGINX_PACKAGES" "$MIRROR_SS_PERMS_NGINX_PACKAGES"
VALIDATE_TMP_SS_PERMS_NGINX_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_NGINX_PACKAGES" ]]; then
    ss_wget "$TMP_SS_PERMS_NGINX_PACKAGES" "$MIRROR2_SS_PERMS_NGINX_PACKAGES"
fi

## ss-perms-nginx-ssl ##
ss_wget "$TMP_SS_PERMS_NGINX_SSL" "$MIRROR_SS_PERMS_NGINX_SSL"
VALIDATE_TMP_SS_PERMS_NGINX_SSL=$(grep 'SS_EOF' "${TMP_SS_PERMS_NGINX_SSL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_NGINX_SSL" ]]; then
    ss_wget "$TMP_SS_PERMS_NGINX_SSL" "$MIRROR2_SS_PERMS_NGINX_SSL"
fi

## ss-perms-opencart-config ##
ss_wget "$TMP_SS_PERMS_OPENCART_CONFIG" "$MIRROR_SS_PERMS_OPENCART_CONFIG"
VALIDATE_TMP_SS_PERMS_OPENCART_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_OPENCART_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_OPENCART_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_OPENCART_CONFIG" "$MIRROR2_SS_PERMS_OPENCART_CONFIG"
fi

## ss-perms-opencart-core ##
ss_wget "$TMP_SS_PERMS_OPENCART_CORE" "$MIRROR_SS_PERMS_OPENCART_CORE"
VALIDATE_TMP_SS_PERMS_OPENCART_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_OPENCART_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_OPENCART_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_OPENCART_CORE" "$MIRROR2_SS_PERMS_OPENCART_CORE"
fi

## ss-perms-php-config ##
ss_wget "$TMP_SS_PERMS_PHP_CONFIG" "$MIRROR_SS_PERMS_PHP_CONFIG"
VALIDATE_TMP_SS_PERMS_PHP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_PHP_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_PHP_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_PHP_CONFIG" "$MIRROR2_SS_PERMS_PHP_CONFIG"
fi

## ss-perms-php-packages ##
ss_wget "$TMP_SS_PERMS_PHP_PACKAGES" "$MIRROR_SS_PERMS_PHP_PACKAGES"
VALIDATE_TMP_SS_PERMS_PHP_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_PHP_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_PHP_PACKAGES" ]]; then
    ss_wget "$TMP_SS_PERMS_PHP_PACKAGES" "$MIRROR2_SS_PERMS_PHP_PACKAGES"
fi

## ss-perms-prestashop-config ##
ss_wget "$TMP_SS_PERMS_PRESTASHOP_CONFIG" "$MIRROR_SS_PERMS_PRESTASHOP_CONFIG"
VALIDATE_TMP_SS_PERMS_PRESTASHOP_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_PRESTASHOP_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_PRESTASHOP_CONFIG" "$MIRROR2_SS_PERMS_PRESTASHOP_CONFIG"
fi

## ss-perms-prestashop-core ##
ss_wget "$TMP_SS_PERMS_PRESTASHOP_CORE" "$MIRROR_SS_PERMS_PRESTASHOP_CORE"
VALIDATE_TMP_SS_PERMS_PRESTASHOP_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_PRESTASHOP_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_PRESTASHOP_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_PRESTASHOP_CORE" "$MIRROR2_SS_PERMS_PRESTASHOP_CORE"
fi

## ss-perms-rclone-config ##
ss_wget "$TMP_SS_PERMS_RCLONE_CONFIG" "$MIRROR_SS_PERMS_RCLONE_CONFIG"
VALIDATE_TMP_SS_PERMS_RCLONE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_RCLONE_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_RCLONE_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_RCLONE_CONFIG" "$MIRROR2_SS_PERMS_RCLONE_CONFIG"
fi

## ss-perms-rclone-packages ##
ss_wget "$TMP_SS_PERMS_RCLONE_PACKAGES" "$MIRROR_SS_PERMS_RCLONE_PACKAGES"
VALIDATE_TMP_SS_PERMS_RCLONE_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_RCLONE_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_RCLONE_PACKAGES" ]]; then
    ss_wget "$TMP_SS_PERMS_RCLONE_PACKAGES" "$MIRROR2_SS_PERMS_RCLONE_PACKAGES"
fi

## ss-perms-redis-config ##
ss_wget "$TMP_SS_PERMS_REDIS_CONFIG" "$MIRROR_SS_PERMS_REDIS_CONFIG"
VALIDATE_TMP_SS_PERMS_REDIS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_REDIS_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_REDIS_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_REDIS_CONFIG" "$MIRROR2_SS_PERMS_REDIS_CONFIG"
fi

## ss-perms-redis-packages ##
ss_wget "$TMP_SS_PERMS_REDIS_PACKAGES" "$MIRROR_SS_PERMS_REDIS_PACKAGES"
VALIDATE_TMP_SS_PERMS_REDIS_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_REDIS_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_REDIS_PACKAGES" ]]; then
    ss_wget "$TMP_SS_PERMS_REDIS_PACKAGES" "$MIRROR2_SS_PERMS_REDIS_PACKAGES"
fi

## ss-perms-ubuntu-bash ##
ss_wget "$TMP_SS_PERMS_UBUNTU_BASH" "$MIRROR_SS_PERMS_UBUNTU_BASH"
VALIDATE_TMP_SS_PERMS_UBUNTU_BASH=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_BASH}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_BASH" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_BASH" "$MIRROR2_SS_PERMS_UBUNTU_BASH"
fi

## ss-perms-ubuntu-crontab ##
ss_wget "$TMP_SS_PERMS_UBUNTU_CRONTAB" "$MIRROR_SS_PERMS_UBUNTU_CRONTAB"
VALIDATE_TMP_SS_PERMS_UBUNTU_CRONTAB=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_CRONTAB}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_CRONTAB" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_CRONTAB" "$MIRROR2_SS_PERMS_UBUNTU_CRONTAB"
fi

## ss-perms-ubuntu-kernel ##
ss_wget "$TMP_SS_PERMS_UBUNTU_KERNEL" "$MIRROR_SS_PERMS_UBUNTU_KERNEL"
VALIDATE_TMP_SS_PERMS_UBUNTU_KERNEL=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_KERNEL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_KERNEL" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_KERNEL" "$MIRROR2_SS_PERMS_UBUNTU_KERNEL"
fi

## ss-perms-ubuntu-ssh ##
ss_wget "$TMP_SS_PERMS_UBUNTU_SSH" "$MIRROR_SS_PERMS_UBUNTU_SSH"
VALIDATE_TMP_SS_PERMS_UBUNTU_SSH=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_SSH}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_SSH" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_SSH" "$MIRROR2_SS_PERMS_UBUNTU_SSH"
fi

## ss-perms-ubuntu-swapfile ##
ss_wget "$TMP_SS_PERMS_UBUNTU_SWAPFILE" "$MIRROR_SS_PERMS_UBUNTU_SWAPFILE"
VALIDATE_TMP_SS_PERMS_UBUNTU_SWAPFILE=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_SWAPFILE" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_SWAPFILE" "$MIRROR2_SS_PERMS_UBUNTU_SWAPFILE"
fi

## ss-perms-ubuntu-users ##
ss_wget "$TMP_SS_PERMS_UBUNTU_USERS" "$MIRROR_SS_PERMS_UBUNTU_USERS"
VALIDATE_TMP_SS_PERMS_UBUNTU_USERS=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_USERS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_USERS" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_USERS" "$MIRROR2_SS_PERMS_UBUNTU_USERS"
fi

## ss-perms-ubuntu-utils ##
ss_wget "$TMP_SS_PERMS_UBUNTU_UTILS" "$MIRROR_SS_PERMS_UBUNTU_UTILS"
VALIDATE_TMP_SS_PERMS_UBUNTU_UTILS=$(grep 'SS_EOF' "${TMP_SS_PERMS_UBUNTU_UTILS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UBUNTU_UTILS" ]]; then
    ss_wget "$TMP_SS_PERMS_UBUNTU_UTILS" "$MIRROR2_SS_PERMS_UBUNTU_UTILS"
fi

## ss-perms-ufw-config ##
ss_wget "$TMP_SS_PERMS_UFW_CONFIG" "$MIRROR_SS_PERMS_UFW_CONFIG"
VALIDATE_TMP_SS_PERMS_UFW_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_UFW_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UFW_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_UFW_CONFIG" "$MIRROR2_SS_PERMS_UFW_CONFIG"
fi

## ss-perms-ufw-packages ##
ss_wget "$TMP_SS_PERMS_UFW_PACKAGES" "$MIRROR_SS_PERMS_UFW_PACKAGES"
VALIDATE_TMP_SS_PERMS_UFW_PACKAGES=$(grep 'SS_EOF' "${TMP_SS_PERMS_UFW_PACKAGES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_UFW_PACKAGES" ]]; then
    ss_wget "$TMP_SS_PERMS_UFW_PACKAGES" "$MIRROR2_SS_PERMS_UFW_PACKAGES"
fi

## ss-perms-wordpress-cli ##
ss_wget "$TMP_SS_PERMS_WORDPRESS_CLI" "$MIRROR_SS_PERMS_WORDPRESS_CLI"
VALIDATE_TMP_SS_PERMS_WORDPRESS_CLI=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CLI}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_WORDPRESS_CLI" ]]; then
    ss_wget "$TMP_SS_PERMS_WORDPRESS_CLI" "$MIRROR2_SS_PERMS_WORDPRESS_CLI"
fi

## ss-perms-wordpress-config ##
ss_wget "$TMP_SS_PERMS_WORDPRESS_CONFIG" "$MIRROR_SS_PERMS_WORDPRESS_CONFIG"
VALIDATE_TMP_SS_PERMS_WORDPRESS_CONFIG=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_WORDPRESS_CONFIG" ]]; then
    ss_wget "$TMP_SS_PERMS_WORDPRESS_CONFIG" "$MIRROR2_SS_PERMS_WORDPRESS_CONFIG"
fi

## ss-perms-wordpress-core ##
ss_wget "$TMP_SS_PERMS_WORDPRESS_CORE" "$MIRROR_SS_PERMS_WORDPRESS_CORE"
VALIDATE_TMP_SS_PERMS_WORDPRESS_CORE=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_CORE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_WORDPRESS_CORE" ]]; then
    ss_wget "$TMP_SS_PERMS_WORDPRESS_CORE" "$MIRROR2_SS_PERMS_WORDPRESS_CORE"
fi

## ss-perms-wordpress-mu-plugins ##
ss_wget "$TMP_SS_PERMS_WORDPRESS_MU_PLUGINS" "$MIRROR_SS_PERMS_WORDPRESS_MU_PLUGINS"
VALIDATE_TMP_SS_PERMS_WORDPRESS_MU_PLUGINS=$(grep 'SS_EOF' "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PERMS_WORDPRESS_MU_PLUGINS" ]]; then
    ss_wget "$TMP_SS_PERMS_WORDPRESS_MU_PLUGINS" "$MIRROR2_SS_PERMS_WORDPRESS_MU_PLUGINS"
fi

## ss-purge-nginx ##
ss_wget "$TMP_SS_PURGE_NGINX" "$MIRROR_SS_PURGE_NGINX"
VALIDATE_TMP_SS_PURGE_NGINX=$(grep 'SS_EOF' "${TMP_SS_PURGE_NGINX}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PURGE_NGINX" ]]; then
    ss_wget "$TMP_SS_PURGE_NGINX" "$MIRROR2_SS_PURGE_NGINX"
fi

## ss-purge-opcache ##
ss_wget "$TMP_SS_PURGE_OPCACHE" "$MIRROR_SS_PURGE_OPCACHE"
VALIDATE_TMP_SS_PURGE_OPCACHE=$(grep 'SS_EOF' "${TMP_SS_PURGE_OPCACHE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PURGE_OPCACHE" ]]; then
    ss_wget "$TMP_SS_PURGE_OPCACHE" "$MIRROR2_SS_PURGE_OPCACHE"
fi

## ss-purge-redis ##
ss_wget "$TMP_SS_PURGE_REDIS" "$MIRROR_SS_PURGE_REDIS"
VALIDATE_TMP_SS_PURGE_REDIS=$(grep 'SS_EOF' "${TMP_SS_PURGE_REDIS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PURGE_REDIS" ]]; then
    ss_wget "$TMP_SS_PURGE_REDIS" "$MIRROR2_SS_PURGE_REDIS"
fi

## ss-purge-transients ##
ss_wget "$TMP_SS_PURGE_TRANSIENTS" "$MIRROR_SS_PURGE_TRANSIENTS"
VALIDATE_TMP_SS_PURGE_TRANSIENTS=$(grep 'SS_EOF' "${TMP_SS_PURGE_TRANSIENTS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PURGE_TRANSIENTS" ]]; then
    ss_wget "$TMP_SS_PURGE_TRANSIENTS" "$MIRROR2_SS_PURGE_TRANSIENTS"
fi

## ss-push-development ##
ss_wget "$TMP_SS_PUSH_DEVELOPMENT" "$MIRROR_SS_PUSH_DEVELOPMENT"
VALIDATE_TMP_SS_PUSH_DEVELOPMENT=$(grep 'SS_EOF' "${TMP_SS_PUSH_DEVELOPMENT}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PUSH_DEVELOPMENT" ]]; then
    ss_wget "$TMP_SS_PUSH_DEVELOPMENT" "$MIRROR2_SS_PUSH_DEVELOPMENT"
fi

## ss-push-staging ##
ss_wget "$TMP_SS_PUSH_STAGING" "$MIRROR_SS_PUSH_STAGING"
VALIDATE_TMP_SS_PUSH_STAGING=$(grep 'SS_EOF' "${TMP_SS_PUSH_STAGING}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_PUSH_STAGING" ]]; then
    ss_wget "$TMP_SS_PUSH_STAGING" "$MIRROR2_SS_PUSH_STAGING"
fi

## ss-reboot-machine ##
ss_wget "$TMP_SS_REBOOT_MACHINE" "$MIRROR_SS_REBOOT_MACHINE"
VALIDATE_TMP_SS_REBOOT_MACHINE=$(grep 'SS_EOF' "${TMP_SS_REBOOT_MACHINE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_REBOOT_MACHINE" ]]; then
    ss_wget "$TMP_SS_REBOOT_MACHINE" "$MIRROR2_SS_REBOOT_MACHINE"
fi

## ss-remote-backup ##
ss_wget "$TMP_SS_REMOTE_BACKUP" "$MIRROR_SS_REMOTE_BACKUP"
VALIDATE_TMP_SS_REMOTE_BACKUP=$(grep 'SS_EOF' "${TMP_SS_REMOTE_BACKUP}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_REMOTE_BACKUP" ]]; then
    ss_wget "$TMP_SS_REMOTE_BACKUP" "$MIRROR2_SS_REMOTE_BACKUP"
fi

## ss-reset-password-sftp ##
ss_wget "$TMP_SS_RESET_PASSWORD_SFTP" "$MIRROR_SS_RESET_PASSWORD_SFTP"
VALIDATE_TMP_SS_RESET_PASSWORD_SFTP=$(grep 'SS_EOF' "${TMP_SS_RESET_PASSWORD_SFTP}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_RESET_PASSWORD_SFTP" ]]; then
    ss_wget "$TMP_SS_RESET_PASSWORD_SFTP" "$MIRROR2_SS_RESET_PASSWORD_SFTP"
fi

## ss-restart-mysql ##
ss_wget "$TMP_SS_RESTART_MYSQL" "$MIRROR_SS_RESTART_MYSQL"
VALIDATE_TMP_SS_RESTART_MYSQL=$(grep 'SS_EOF' "${TMP_SS_RESTART_MYSQL}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_RESTART_MYSQL" ]]; then
    ss_wget "$TMP_SS_RESTART_MYSQL" "$MIRROR2_SS_RESTART_MYSQL"
fi

## ss-restart-nginx ##
ss_wget "$TMP_SS_RESTART_NGINX" "$MIRROR_SS_RESTART_NGINX"
VALIDATE_TMP_SS_RESTART_NGINX=$(grep 'SS_EOF' "${TMP_SS_RESTART_NGINX}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_RESTART_NGINX" ]]; then
    ss_wget "$TMP_SS_RESTART_NGINX" "$MIRROR2_SS_RESTART_NGINX"
fi

## ss-restart-php ##
ss_wget "$TMP_SS_RESTART_PHP" "$MIRROR_SS_RESTART_PHP"
VALIDATE_TMP_SS_RESTART_PHP=$(grep 'SS_EOF' "${TMP_SS_RESTART_PHP}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_RESTART_PHP" ]]; then
    ss_wget "$TMP_SS_RESTART_PHP" "$MIRROR2_SS_RESTART_PHP"
fi

## ss-restart-redis ##
ss_wget "$TMP_SS_RESTART_REDIS" "$MIRROR_SS_RESTART_REDIS"
VALIDATE_TMP_SS_RESTART_REDIS=$(grep 'SS_EOF' "${TMP_SS_RESTART_REDIS}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_RESTART_REDIS" ]]; then
    ss_wget "$TMP_SS_RESTART_REDIS" "$MIRROR2_SS_RESTART_REDIS"
fi

## ss-restart-ufw ##
ss_wget "$TMP_SS_RESTART_UFW" "$MIRROR_SS_RESTART_UFW"
VALIDATE_TMP_SS_RESTART_UFW=$(grep 'SS_EOF' "${TMP_SS_RESTART_UFW}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_RESTART_UFW" ]]; then
    ss_wget "$TMP_SS_RESTART_UFW" "$MIRROR2_SS_RESTART_UFW"
fi

## ss-scan-malware ##
ss_wget "$TMP_SS_SCAN_MALWARE" "$MIRROR_SS_SCAN_MALWARE"
VALIDATE_TMP_SS_SCAN_MALWARE=$(grep 'SS_EOF' "${TMP_SS_SCAN_MALWARE}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_SCAN_MALWARE" ]]; then
    ss_wget "$TMP_SS_SCAN_MALWARE" "$MIRROR2_SS_SCAN_MALWARE"
fi

## ss-stack-overview ##
ss_wget "$TMP_SS_STACK_OVERVIEW" "$MIRROR_SS_STACK_OVERVIEW"
VALIDATE_TMP_SS_STACK_OVERVIEW=$(grep 'SS_EOF' "${TMP_SS_STACK_OVERVIEW}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_STACK_OVERVIEW" ]]; then
    ss_wget "$TMP_SS_STACK_OVERVIEW" "$MIRROR2_SS_STACK_OVERVIEW"
fi

## ss-sync-development ##
ss_wget "$TMP_SS_SYNC_DEVELOPMENT" "$MIRROR_SS_SYNC_DEVELOPMENT"
VALIDATE_TMP_SS_SYNC_DEVELOPMENT=$(grep 'SS_EOF' "${TMP_SS_SYNC_DEVELOPMENT}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_SYNC_DEVELOPMENT" ]]; then
    ss_wget "$TMP_SS_SYNC_DEVELOPMENT" "$MIRROR2_SS_SYNC_DEVELOPMENT"
fi

## ss-sync-staging ##
ss_wget "$TMP_SS_SYNC_STAGING" "$MIRROR_SS_SYNC_STAGING"
VALIDATE_TMP_SS_SYNC_STAGING=$(grep 'SS_EOF' "${TMP_SS_SYNC_STAGING}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_SYNC_STAGING" ]]; then
    ss_wget "$TMP_SS_SYNC_STAGING" "$MIRROR2_SS_SYNC_STAGING"
fi

## ss-update-config ##
ss_wget "$TMP_SS_UPDATE_CONFIG" "$MIRROR_SS_UPDATE_CONFIG"
VALIDATE_TMP_SS_UPDATE_CONFIG=$(grep 'SS_EOF' "${TMP_SS_UPDATE_CONFIG}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_UPDATE_CONFIG" ]]; then
    ss_wget "$TMP_SS_UPDATE_CONFIG" "$MIRROR2_SS_UPDATE_CONFIG"
fi

## ss-update-modules ##
ss_wget "$TMP_SS_UPDATE_MODULES" "$MIRROR_SS_UPDATE_MODULES"
VALIDATE_TMP_SS_UPDATE_MODULES=$(grep 'SS_EOF' "${TMP_SS_UPDATE_MODULES}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_UPDATE_MODULES" ]]; then
    ss_wget "$TMP_SS_UPDATE_MODULES" "$MIRROR2_SS_UPDATE_MODULES"
fi

## ss-worker ##
ss_wget "$TMP_SS_WORKER" "$MIRROR_SS_WORKER"
VALIDATE_TMP_SS_WORKER=$(grep 'SS_EOF' "${TMP_SS_WORKER}" 2> /dev/null)
if [[ -z "$VALIDATE_TMP_SS_WORKER" ]]; then
    ss_wget "$TMP_SS_WORKER" "$MIRROR2_SS_WORKER"
fi

####################################################################################################
#### F. SS-Check: Install Cron Jobs ################################################################
####################################################################################################

## here we copy all the downloaded core files to the proper folders where they remain ##
## the root crontab runs the core cron jobs which in turn run the bash scripts ##

if [[ -n "${VALIDATE_TMP_00_CRONTAB}" ]]; then
    ss_mv "${TMP_00_CRONTAB}" "${PATH_00_CRONTAB}"
fi

if [[ -n "${VALIDATE_TMP_01_CRON_OFTEN}" ]]; then
    ss_mv "${TMP_01_CRON_OFTEN}" "${PATH_01_CRON_OFTEN}"
fi

if [[ -n "${VALIDATE_TMP_02_CRON_REGULAR}" ]]; then
    ss_mv "${TMP_02_CRON_REGULAR}" "${PATH_02_CRON_REGULAR}"
fi

if [[ -n "${VALIDATE_TMP_03_CRON_QUARTER_HOURLY}" ]]; then
    ss_mv "${TMP_03_CRON_QUARTER_HOURLY}" "${PATH_03_CRON_QUARTER_HOURLY}"
fi

if [[ -n "${VALIDATE_TMP_04_CRON_HALF_HOURLY}" ]]; then
    ss_mv "${TMP_04_CRON_HALF_HOURLY}" "${PATH_04_CRON_HALF_HOURLY}"
fi

if [[ -n "${VALIDATE_TMP_05_CRON_HOURLY}" ]]; then
    ss_mv "${TMP_05_CRON_HOURLY}" "${PATH_05_CRON_HOURLY}"
fi

if [[ -n "${VALIDATE_TMP_06_CRON_QUARTER_DAILY}" ]]; then
    ss_mv "${TMP_06_CRON_QUARTER_DAILY}" "${PATH_06_CRON_QUARTER_DAILY}"
fi

if [[ -n "${VALIDATE_TMP_07_CRON_HALF_DAILY}" ]]; then
    ss_mv "${TMP_07_CRON_HALF_DAILY}" "${PATH_07_CRON_HALF_DAILY}"
fi

if [[ -n "${VALIDATE_TMP_08_CRON_DAILY}" ]]; then
    ss_mv "${TMP_08_CRON_DAILY}" "${PATH_08_CRON_DAILY}"
fi

if [[ -n "${VALIDATE_TMP_09_CRON_HALF_WEEKLY}" ]]; then
    ss_mv "${TMP_09_CRON_HALF_WEEKLY}" "${PATH_09_CRON_HALF_WEEKLY}"
fi

if [[ -n "${VALIDATE_TMP_10_CRON_WEEKLY}" ]]; then
    ss_mv "${TMP_10_CRON_WEEKLY}" "${PATH_10_CRON_WEEKLY}"
fi

if [[ -n "${VALIDATE_TMP_11_CRON_HALF_MONTHLY}" ]]; then
    ss_mv "${TMP_11_CRON_HALF_MONTHLY}" "${PATH_11_CRON_HALF_MONTHLY}"
fi

if [[ -n "${VALIDATE_TMP_12_CRON_MONTHLY}" ]]; then
    ss_mv "${TMP_12_CRON_MONTHLY}" "${PATH_12_CRON_MONTHLY}"
fi

if [[ -n "${VALIDATE_TMP_13_CRON_SOMETIMES}" ]]; then
    ss_mv "${TMP_13_CRON_SOMETIMES}" "${PATH_13_CRON_SOMETIMES}"
fi

####################################################################################################
#### G. SS-Check: Install Bash Scripts (Except SS-Check) ###########################################
####################################################################################################

## install bash scripts ##
ss_mv "${TMP_SS_CLEAN_DATABASE}" "${PATH_SS_CLEAN_DATABASE}"
ss_mv "${TMP_SS_CLEAN_FILES}" "${PATH_SS_CLEAN_FILES}"
ss_mv "${TMP_SS_CONFIG_SAMPLE}" "${PATH_SS_CONFIG_SAMPLE}"
ss_mv "${TMP_SS_DELETE_DATABASE}" "${PATH_SS_DELETE_DATABASE}"
ss_mv "${TMP_SS_DELETE_FILES}" "${PATH_SS_DELETE_FILES}"
ss_mv "${TMP_SS_DUMP_DATABASE}" "${PATH_SS_DUMP_DATABASE}"
ss_mv "${TMP_SS_DUMP_FILES}" "${PATH_SS_DUMP_FILES}"
ss_mv "${TMP_SS_EMPTY_LOGS}" "${PATH_SS_EMPTY_LOGS}"
ss_mv "${TMP_SS_ENCRYPT_ACME}" "${PATH_SS_ENCRYPT_ACME}"
ss_mv "${TMP_SS_ENCRYPT_CERTBOT}" "${PATH_SS_ENCRYPT_CERTBOT}"
ss_mv "${TMP_SS_ENCRYPT_OPENSSL}" "${PATH_SS_ENCRYPT_OPENSSL}"
ss_mv "${TMP_SS_FUNCTIONS}" "${PATH_SS_FUNCTIONS}"
ss_mv "${TMP_SS_IMPORT_DATABASE}" "${PATH_SS_IMPORT_DATABASE}"
ss_mv "${TMP_SS_IMPORT_FILES}" "${PATH_SS_IMPORT_FILES}"
ss_mv "${TMP_SS_INSTALL}" "${PATH_SS_INSTALL}"
ss_mv "${TMP_SS_INSTALL_ADMINER}" "${PATH_SS_INSTALL_ADMINER}"
ss_mv "${TMP_SS_INSTALL_CLAMAV}" "${PATH_SS_INSTALL_CLAMAV}"
ss_mv "${TMP_SS_INSTALL_CRAFT_CONFIG}" "${PATH_SS_INSTALL_CRAFT_CONFIG}"
ss_mv "${TMP_SS_INSTALL_CRAFT_CORE}" "${PATH_SS_INSTALL_CRAFT_CORE}"
ss_mv "${TMP_SS_INSTALL_MEDIAWIKI_CONFIG}" "${PATH_SS_INSTALL_MEDIAWIKI_CONFIG}"
ss_mv "${TMP_SS_INSTALL_MEDIAWIKI_CORE}" "${PATH_SS_INSTALL_MEDIAWIKI_CORE}"
ss_mv "${TMP_SS_INSTALL_MOODLE_CONFIG}" "${PATH_SS_INSTALL_MOODLE_CONFIG}"
ss_mv "${TMP_SS_INSTALL_MOODLE_CORE}" "${PATH_SS_INSTALL_MOODLE_CORE}"
ss_mv "${TMP_SS_INSTALL_MYSQL_CONFIG}" "${PATH_SS_INSTALL_MYSQL_CONFIG}"
ss_mv "${TMP_SS_INSTALL_MYSQL_DATABASE}" "${PATH_SS_INSTALL_MYSQL_DATABASE}"
ss_mv "${TMP_SS_INSTALL_MYSQL_PACKAGES}" "${PATH_SS_INSTALL_MYSQL_PACKAGES}"
ss_mv "${TMP_SS_INSTALL_NGINX_CONFIG}" "${PATH_SS_INSTALL_NGINX_CONFIG}"
ss_mv "${TMP_SS_INSTALL_NGINX_LETSENCRYPT}" "${PATH_SS_INSTALL_NGINX_LETSENCRYPT}"
ss_mv "${TMP_SS_INSTALL_NGINX_OPENSSL}" "${PATH_SS_INSTALL_NGINX_OPENSSL}"
ss_mv "${TMP_SS_INSTALL_NGINX_PACKAGES}" "${PATH_SS_INSTALL_NGINX_PACKAGES}"
ss_mv "${TMP_SS_INSTALL_NGINX_SSL}" "${PATH_SS_INSTALL_NGINX_SSL}"
ss_mv "${TMP_SS_INSTALL_OPENCART_CONFIG}" "${PATH_SS_INSTALL_OPENCART_CONFIG}"
ss_mv "${TMP_SS_INSTALL_OPENCART_CORE}" "${PATH_SS_INSTALL_OPENCART_CORE}"
ss_mv "${TMP_SS_INSTALL_PHP_CONFIG}" "${PATH_SS_INSTALL_PHP_CONFIG}"
ss_mv "${TMP_SS_INSTALL_PHP_PACKAGES}" "${PATH_SS_INSTALL_PHP_PACKAGES}"
ss_mv "${TMP_SS_INSTALL_PRESTASHOP_CONFIG}" "${PATH_SS_INSTALL_PRESTASHOP_CONFIG}"
ss_mv "${TMP_SS_INSTALL_PRESTASHOP_CORE}" "${PATH_SS_INSTALL_PRESTASHOP_CORE}"
ss_mv "${TMP_SS_INSTALL_RCLONE_CONFIG}" "${PATH_SS_INSTALL_RCLONE_CONFIG}"
ss_mv "${TMP_SS_INSTALL_RCLONE_PACKAGES}" "${PATH_SS_INSTALL_RCLONE_PACKAGES}"
ss_mv "${TMP_SS_INSTALL_REDIS_CONFIG}" "${PATH_SS_INSTALL_REDIS_CONFIG}"
ss_mv "${TMP_SS_INSTALL_REDIS_PACKAGES}" "${PATH_SS_INSTALL_REDIS_PACKAGES}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_BASH}" "${PATH_SS_INSTALL_UBUNTU_BASH}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_CRONTAB}" "${PATH_SS_INSTALL_UBUNTU_CRONTAB}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_KERNEL}" "${PATH_SS_INSTALL_UBUNTU_KERNEL}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_SSH}" "${PATH_SS_INSTALL_UBUNTU_SSH}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_SWAPFILE}" "${PATH_SS_INSTALL_UBUNTU_SWAPFILE}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_USERS}" "${PATH_SS_INSTALL_UBUNTU_USERS}"
ss_mv "${TMP_SS_INSTALL_UBUNTU_UTILS}" "${PATH_SS_INSTALL_UBUNTU_UTILS}"
ss_mv "${TMP_SS_INSTALL_UFW_CONFIG}" "${PATH_SS_INSTALL_UFW_CONFIG}"
ss_mv "${TMP_SS_INSTALL_UFW_PACKAGES}" "${PATH_SS_INSTALL_UFW_PACKAGES}"
ss_mv "${TMP_SS_INSTALL_WORDPRESS_CLI}" "${PATH_SS_INSTALL_WORDPRESS_CLI}"
ss_mv "${TMP_SS_INSTALL_WORDPRESS_CONFIG}" "${PATH_SS_INSTALL_WORDPRESS_CONFIG}"
ss_mv "${TMP_SS_INSTALL_WORDPRESS_CORE}" "${PATH_SS_INSTALL_WORDPRESS_CORE}"
ss_mv "${TMP_SS_INSTALL_WORDPRESS_MU_PLUGINS}" "${PATH_SS_INSTALL_WORDPRESS_MU_PLUGINS}"
ss_mv "${TMP_SS_MAINTENANCE_DISABLE}" "${PATH_SS_MAINTENANCE_DISABLE}"
ss_mv "${TMP_SS_MAINTENANCE_ENABLE}" "${PATH_SS_MAINTENANCE_ENABLE}"
ss_mv "${TMP_SS_MONITOR_RESOURCES}" "${PATH_SS_MONITOR_RESOURCES}"
ss_mv "${TMP_SS_OPTIMIZE_DATABASE}" "${PATH_SS_OPTIMIZE_DATABASE}"
ss_mv "${TMP_SS_OPTIMIZE_FILES}" "${PATH_SS_OPTIMIZE_FILES}"
ss_mv "${TMP_SS_PERMS}" "${PATH_SS_PERMS}"
ss_mv "${TMP_SS_PERMS_ADMINER}" "${PATH_SS_PERMS_ADMINER}"
ss_mv "${TMP_SS_PERMS_CLAMAV}" "${PATH_SS_PERMS_CLAMAV}"
ss_mv "${TMP_SS_PERMS_CRAFT_CONFIG}" "${PATH_SS_PERMS_CRAFT_CONFIG}"
ss_mv "${TMP_SS_PERMS_CRAFT_CORE}" "${PATH_SS_PERMS_CRAFT_CORE}"
ss_mv "${TMP_SS_PERMS_MAGENTO_CONFIG}" "${PATH_SS_PERMS_MAGENTO_CONFIG}"
ss_mv "${TMP_SS_PERMS_MAGENTO_CORE}" "${PATH_SS_PERMS_MAGENTO_CORE}"
ss_mv "${TMP_SS_PERMS_MEDIAWIKI_CONFIG}" "${PATH_SS_PERMS_MEDIAWIKI_CONFIG}"
ss_mv "${TMP_SS_PERMS_MEDIAWIKI_CORE}" "${PATH_SS_PERMS_MEDIAWIKI_CORE}"
ss_mv "${TMP_SS_PERMS_MOODLE_CONFIG}" "${PATH_SS_PERMS_MOODLE_CONFIG}"
ss_mv "${TMP_SS_PERMS_MOODLE_CORE}" "${PATH_SS_PERMS_MOODLE_CORE}"
ss_mv "${TMP_SS_PERMS_MYSQL_CONFIG}" "${PATH_SS_PERMS_MYSQL_CONFIG}"
ss_mv "${TMP_SS_PERMS_MYSQL_DATABASE}" "${PATH_SS_PERMS_MYSQL_DATABASE}"
ss_mv "${TMP_SS_PERMS_MYSQL_PACKAGES}" "${PATH_SS_PERMS_MYSQL_PACKAGES}"
ss_mv "${TMP_SS_PERMS_NGINX_CONFIG}" "${PATH_SS_PERMS_NGINX_CONFIG}"
ss_mv "${TMP_SS_PERMS_NGINX_PACKAGES}" "${PATH_SS_PERMS_NGINX_PACKAGES}"
ss_mv "${TMP_SS_PERMS_NGINX_SSL}" "${PATH_SS_PERMS_NGINX_SSL}"
ss_mv "${TMP_SS_PERMS_OPENCART_CONFIG}" "${PATH_SS_PERMS_OPENCART_CONFIG}"
ss_mv "${TMP_SS_PERMS_OPENCART_CORE}" "${PATH_SS_PERMS_OPENCART_CORE}"
ss_mv "${TMP_SS_PERMS_PHP_CONFIG}" "${PATH_SS_PERMS_PHP_CONFIG}"
ss_mv "${TMP_SS_PERMS_PHP_PACKAGES}" "${PATH_SS_PERMS_PHP_PACKAGES}"
ss_mv "${TMP_SS_PERMS_PRESTASHOP_CONFIG}" "${PATH_SS_PERMS_PRESTASHOP_CONFIG}"
ss_mv "${TMP_SS_PERMS_PRESTASHOP_CORE}" "${PATH_SS_PERMS_PRESTASHOP_CORE}"
ss_mv "${TMP_SS_PERMS_RCLONE_CONFIG}" "${PATH_SS_PERMS_RCLONE_CONFIG}"
ss_mv "${TMP_SS_PERMS_RCLONE_PACKAGES}" "${PATH_SS_PERMS_RCLONE_PACKAGES}"
ss_mv "${TMP_SS_PERMS_REDIS_CONFIG}" "${PATH_SS_PERMS_REDIS_CONFIG}"
ss_mv "${TMP_SS_PERMS_REDIS_PACKAGES}" "${PATH_SS_PERMS_REDIS_PACKAGES}"
ss_mv "${TMP_SS_PERMS_UBUNTU_BASH}" "${PATH_SS_PERMS_UBUNTU_BASH}"
ss_mv "${TMP_SS_PERMS_UBUNTU_CRONTAB}" "${PATH_SS_PERMS_UBUNTU_CRONTAB}"
ss_mv "${TMP_SS_PERMS_UBUNTU_KERNEL}" "${PATH_SS_PERMS_UBUNTU_KERNEL}"
ss_mv "${TMP_SS_PERMS_UBUNTU_SSH}" "${PATH_SS_PERMS_UBUNTU_SSH}"
ss_mv "${TMP_SS_PERMS_UBUNTU_SWAPFILE}" "${PATH_SS_PERMS_UBUNTU_SWAPFILE}"
ss_mv "${TMP_SS_PERMS_UBUNTU_USERS}" "${PATH_SS_PERMS_UBUNTU_USERS}"
ss_mv "${TMP_SS_PERMS_UBUNTU_UTILS}" "${PATH_SS_PERMS_UBUNTU_UTILS}"
ss_mv "${TMP_SS_PERMS_UFW_CONFIG}" "${PATH_SS_PERMS_UFW_CONFIG}"
ss_mv "${TMP_SS_PERMS_UFW_PACKAGES}" "${PATH_SS_PERMS_UFW_PACKAGES}"
ss_mv "${TMP_SS_PERMS_WORDPRESS_CLI}" "${PATH_SS_PERMS_WORDPRESS_CLI}"
ss_mv "${TMP_SS_PERMS_WORDPRESS_CONFIG}" "${PATH_SS_PERMS_WORDPRESS_CONFIG}"
ss_mv "${TMP_SS_PERMS_WORDPRESS_CORE}" "${PATH_SS_PERMS_WORDPRESS_CORE}"
ss_mv "${TMP_SS_PERMS_WORDPRESS_MU_PLUGINS}" "${PATH_SS_PERMS_WORDPRESS_MU_PLUGINS}"
ss_mv "${TMP_SS_PURGE_NGINX}" "${PATH_SS_PURGE_NGINX}"
ss_mv "${TMP_SS_PURGE_OPCACHE}" "${PATH_SS_PURGE_OPCACHE}"
ss_mv "${TMP_SS_PURGE_REDIS}" "${PATH_SS_PURGE_REDIS}"
ss_mv "${TMP_SS_PURGE_TRANSIENTS}" "${PATH_SS_PURGE_TRANSIENTS}"
ss_mv "${TMP_SS_PUSH_DEVELOPMENT}" "${PATH_SS_PUSH_DEVELOPMENT}"
ss_mv "${TMP_SS_PUSH_STAGING}" "${PATH_SS_PUSH_STAGING}"
ss_mv "${TMP_SS_REBOOT_MACHINE}" "${PATH_SS_REBOOT_MACHINE}"
ss_mv "${TMP_SS_REMOTE_BACKUP}" "${PATH_SS_REMOTE_BACKUP}"
ss_mv "${TMP_SS_RESET_PASSWORD_SFTP}" "${PATH_SS_RESET_PASSWORD_SFTP}"
ss_mv "${TMP_SS_RESTART_MYSQL}" "${PATH_SS_RESTART_MYSQL}"
ss_mv "${TMP_SS_RESTART_NGINX}" "${PATH_SS_RESTART_NGINX}"
ss_mv "${TMP_SS_RESTART_PHP}" "${PATH_SS_RESTART_PHP}"
ss_mv "${TMP_SS_RESTART_REDIS}" "${PATH_SS_RESTART_REDIS}"
ss_mv "${TMP_SS_RESTART_UFW}" "${PATH_SS_RESTART_UFW}"
ss_mv "${TMP_SS_SCAN_MALWARE}" "${PATH_SS_SCAN_MALWARE}"
ss_mv "${TMP_SS_STACK_OVERVIEW}" "${PATH_SS_STACK_OVERVIEW}"
ss_mv "${TMP_SS_SYNC_DEVELOPMENT}" "${PATH_SS_SYNC_DEVELOPMENT}"
ss_mv "${TMP_SS_SYNC_STAGING}" "${PATH_SS_SYNC_STAGING}"
ss_mv "${TMP_SS_UPDATE_CONFIG}" "${PATH_SS_UPDATE_CONFIG}"
ss_mv "${TMP_SS_UPDATE_MODULES}" "${PATH_SS_UPDATE_MODULES}"
ss_mv "${TMP_SS_WORKER}" "${PATH_SS_WORKER}"

####################################################################################################
#### PLACEHOLDER: Reset Permissions (SlickStack Scripts) ###########################################
####################################################################################################

## we include this permissions reset in all cron jobs and bash scripts for redundancy ##
## chmod 0700 means only the root/sudo users can execute any SlickStack scripts ##

## THIS SNIPPET DOES NOT RELY ON SS-CONFIG OR SS-FUNCTIONS
## SNIPPET: ss bash scripts, ss cron jobs
## UPDATED: 02JUL2022

chown root:root /var/www/ss* ## must be root:root
chown root:root /var/www/crons/*cron* ## must be root:root
chown root:root /var/www/crons/custom/*cron* ## must be root:root
chmod 0700 /var/www/ss* ## 0700 means only root/sudo can execute
chmod 0700 /var/www/crons/*cron* ## 0700 means only root/sudo can execute
chmod 0700 /var/www/crons/custom/*cron* ## 0700 means only root/sudo can execute

####################################################################################################
#### SlickStack: External References Used To Improve This Script (Thanks, Interwebz) ###############
####################################################################################################

## Ref: https://linuxize.com/post/bash-functions/
## Ref: https://stackoverflow.com/questions/6366530/bash-syntax-error-unexpected-end-of-file
## Ref: https://gist.github.com/onnimonni/b49779ebc96216771a6be3de46449fa1
## Ref: https://www.putorius.net/linux-checksum-file-integrity-check.html
## Ref: https://unix.stackexchange.com/questions/254868/use-md5sum-to-verify-file-in-a-script
## Ref: https://unix.stackexchange.com/questions/118085/transform-a-directory-into-file-or-a-file-into-directory

## SS_EOF