make-compose.sh

#!/usr/bin/env bash

. versions.sh
if [ -f  env.sh ]; then
    . env.sh
fi
DATA_SOURCES=""
CURRENT_VERSION="master"
LOKI_WALL_DIR="./loki-wall"
if [ -f CURRENT_VERSION.sh ]; then
    CURRENT_VERSION=`cat CURRENT_VERSION.sh`
fi

if [ -z "$BRANCH_VERSION" ]; then
  BRANCH_VERSION=$CURRENT_VERSION
fi
if [ -z ${DEFAULT_VERSION[$CURRENT_VERSION]} ]; then
    BRANCH_VERSION=`echo $CURRENT_VERSION|cut -d'.' -f1,2`
fi
if [ "$1" = "-e" ]; then
    DEFAULT_VERSION=${DEFAULT_ENTERPRISE_VERSION[$BRANCH_VERSION]}
fi

if [ -z "$MANAGER_VERSION" ];then
  MANAGER_VERSION=${MANAGER_DEFAULT_VERSION[$BRANCH_VERSION]}
fi

if [ "$CURRENT_VERSION" = "master" ]; then
    echo ""
    echo "*****************************************************"
    echo "* WARNING: You are using the unstable master branch *"
    echo "* Check the README.md file for the stable releases  *"
    echo "*****************************************************"
    echo ""
    echo "Make sure you run generate-dashboards.sh to generate your dashboards."
    echo 'For example to use Scylla 2021.1 run `./generate-dashboards.sh -F -v 2021.1`'
    echo ""
fi
if [ -z $LOKI_RULE_DIR ]; then
	LOKI_RULE_DIR=./loki/rules/scylla
fi
if [ -z $LOKI_CONF_DIR ]; then
	LOKI_CONF_DIR=./loki/conf
fi
if [ -z $PROMTAIL_CONFIG ]; then
	PROMTAIL_CONFIG=$PWD/loki/promtail/promtail_config.yml
fi
if [ "`id -u`" -eq 0 ]; then
    echo "Running as root is not advised, please check the documentation on how to run as non-root user"
else
    GROUPID=`id -g`
    PROMETHEUS_USER_PERMISSIONS="user: $UID:$GROUPID"
    LOKi_USER_PERMISSIONS="user: $UID:$GROUPID"
fi

if [[ $(uname) == "Linux" ]]; then
  readlink_command="readlink -f"
elif [[ $(uname) == "Darwin" ]]; then
  readlink_command="realpath "
fi

function usage {
  __usage="Usage: $(basename $0) [-h] [--version] [-e] [-d Prometheus data-dir] [-L resolve the servers from the manger running on the given address] [-G path to grafana data-dir] [-s scylla-target-file] [-n node-target-file] [-l] [-v comma separated versions] [-j additional dashboard to load to Grafana, multiple params are supported] [-c grafana environment variable, multiple params are supported] [-b Prometheus command line options] [-g grafana port ] [ -p prometheus port ] [-a admin password] [-m alertmanager port] [ -M scylla-manager version ] [-D encapsulate docker param] [-r alert-manager-config] [-R prometheus-alert-file] [-N manager target file] [-A bind-to-ip-address] [-C alertmanager commands] [-Q Grafana anonymous role (Admin/Editor/Viewer)] [-S start with a system specific dashboard set] [-T additional-prometheus-targets] [--no-loki] [--auto-restart] [--no-renderer] [-f alertmanager-dir]

Options:
  -h print this help and exit
  --version print the current monitoring version and the supported versions and exit.
  -e
  -d path/to/Prometheus/data/dir - Set an external data directory for the Prometheus data
  -L ip                          - Resolve the servers from a Scylla Manager running on the given address.
  -G path/to/Grafana/data-dir    - Set an external data directory for the Grafana data.
  -s path/to/scylla-target-file  - Read Scylla's target from the given file.
  -n path/to/node-target-file    - Override scylla target file for node_exporter.
  -l                             - If Set use the local host network, especially useful when a container needs
                                   to access the local host.
  -v comma separated versions    - Specify one or more Scylla versions, check --version for the supported versions.
  -j additional dashboard        - List additional dashboards to load to Grafana, multiple params are supported.
  -c grafana_environment         - Grafana environment variable, multiple params are supported.
  -b Prometheus command          - Prometheus command line options.
  -g grafana port                - Override the default Grafana port.
  -p prometheus port             - Override the default Prometheus port.
  -a admin password              - Set Grafna's Admin password.
  -m alertmanager port           - Override the default Prometheus port.
  -M scylla-manager version      - Override the default Scylla Manager version to use.
  -D docker param                - Encapsulate docker param, the parameter will be used by all containers.
  -r alert-manager-config        - Override the default alert-manager configuration file.
  -f path/to/alertmanager/data   - If set, the alertmanager would store its data in the given directory.
  -R prometheus-alert-file       - Override the default Prometheus alerts configuration file.
  -N path/to/manager/target file - Set the location of the target file for Scylla Manager.
  -A bind-to-ip-address          - Bind to a specific interface.
  -C alertmanager commands       - Pass the command to the alertmanager.
  -Q Grafana anonymous role      - Set the Grafana anonymous role to one of Admin/Editor/Viewer.
  -S dashbards-list              - Override the default set of dashboards with the spcefied one.
  -T path/to/prometheus-targets  - Adds additional Prometheus target files.
  -k path/to/loki/storage        - When set, will use the given directory for Loki's data
  --no-loki                      - If set, do not run Loki and promtail.
  --no-cas                       - If set, Prometheus will drop all cas related metrics while scrapping
  --no-cdc                       - If set, Prometheus will drop all cdc related metrics while scrapping
  --auto-restart                 - If set, auto restarts the containers on failure.
  --no-renderer                  - If set, do not run the Grafana renderer container.
  --thanos-sc                    - If set, run thanos side car with the Prometheus server.
  --thanos                       - If set, run thanos query as a Grafana datasource.
  --target-directory             - If set, prometheus/targets/ directory will be set as a root directory for the target files
                                   the file names should be scylla_server.yml, node_exporter_servers.yml, and  scylla_manager_servers.yml
  --limit container,param        - Allow to set a specific Docker parameter for a container, where container can be:
                                   prometheus, grafana, alertmanager, loki, sidecar, grafanarender
  --archive                      - Treat data directory as an archive. This disables Prometheus time-to-live (infinite retention).
The script starts Scylla Monitoring stack.
"
  echo "$__usage"
}

function is_local () {
    for var in "$@"; do
        if grep -q '\s127.' $1; then
            echo "Local host found in $1"
            grep '\s127.' $1
            return 0
        fi
        if grep -q 'localhost' $1; then
            return 0
        fi
    done
    return 1
}

function add_param() {
	arr=("$@")
	for value in "${arr[@]}"; do
        echo -n "    - $value\n"
    done
}

function set_path() {
	if [[ "$1" == "."* || "$1" == "/"* ]]; then
		echo $1
	else
		echo "./$1"
	fi
}

if [ -z "$GF_AUTH_BASIC_ENABLED" ]; then
	GF_AUTH_BASIC_ENABLED=false
fi

if [ -z "$GF_AUTH_ANONYMOUS_ENABLED" ]; then
	GF_AUTH_ANONYMOUS_ENABLED=true
fi
if [ -z "$GF_AUTH_ANONYMOUS_ORG_ROLE" ]; then
	GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
fi
if [ -z "$GF_SECURITY_ADMIN_PASSWORD" ]; then
	GF_SECURITY_ADMIN_PASSWORD=admin
fi

if [ -z "$PROMETHEUS_RULES" ]; then
  PROMETHEUS_RULES="$PWD/prometheus/prom_rules/:/etc/prometheus/prom_rules/"
fi

if [ -z "$VERSIONS" ]; then
  VERSIONS=${DEFAULT_VERSION[$BRANCH_VERSION]}
fi

if [ -z "$SCYLLA_TARGET_FILES" ]; then
  SCYLLA_TARGET_FILES=($PWD/prometheus/scylla_servers.yml $PWD/scylla_servers.yml)
fi
if [ -z "$SCYLLA_MANGER_TARGET_FILES" ]; then
  SCYLLA_MANGER_TARGET_FILES=($PWD/prometheus/scylla_manager_servers.yml $PWD/scylla_manager_servers.yml $PWD/prometheus/scylla_manager_servers.example.yml)
fi
if [ -z "$GRAFANA_ADMIN_PASSWORD" ]; then
  GRAFANA_ADMIN_PASSWORD=""
fi

if [ -z "$ALERTMANAGER_PORT" ]; then
  ALERTMANAGER_PORT=""
fi

if [ -z "$LOKI_PORT" ]; then
	LOKI_PORT=3100
fi
if [ -z "$DOCKER_PARAM" ]; then
  DOCKER_PARAM=""
fi
if [ -z "$DATA_DIR" ]; then
  DATA_DIR=""
fi
if [ -z "$DATA_DIR_CMD" ]; then
  DATA_DIR_CMD=""
fi
if [ -z "$CONSUL_ADDRESS" ]; then
  CONSUL_ADDRESS=""
fi
if [ -z "$PROMETHEUS_TARGETS" ]; then
  PROMETHEUS_TARGETS=""
fi
if [ -z "$BIND_ADDRESS" ]; then
  BIND_ADDRESS=""
fi
if [ -z "$GRAFNA_ANONYMOUS_ROLE" ]; then
  GRAFNA_ANONYMOUS_ROLE=""
fi
if [ -z "$SPECIFIC_SOLUTION" ]; then
  SPECIFIC_SOLUTION=""
fi
if [ -z "$LDAP_FILE" ]; then
  LDAP_FILE=""
fi
if [ -z "$RUN_RENDERER" ]; then
  RUN_RENDERER="-E"
fi
if [ -z "$RUN_LOKI" ]; then
  RUN_LOKI=1
fi
if [ -z "$RUN_THANOS_SC" ]; then
  RUN_THANOS_SC=0
fi
if [ -z "$RUN_THANOS" ]; then
  RUN_THANOS=0
fi
if [ -z "$ALERT_MANAGER_DIR" ]; then
  ALERT_MANAGER_DIR=""
fi
if [ -z "$LOKI_DIR" ]; then
  LOKI_DIR=""
fi
for arg; do
    shift
    if [ -z "$LIMIT" ]; then
       case $arg in
            (--compose) RUN_COMPOSE=1
                ;;
            (--no-loki) RUN_LOKI=0
                ;;
            (--no-renderer) RUN_RENDERER=""
                ;;
            (--thanos-sc) RUN_THANOS_SC=1
                ;;
            (--thanos) RUN_THANOS=1
                ;;
            (--auto-restart) DOCKER_PARAM="$DOCKER_PARAM    restart: unless-stopped\n"
                ;;
            (--victoria-metrics) VICTORIA_METRICS="1"
                ;;
            (--auth)
                GF_AUTH_BASIC_ENABLED="true"
                ;;
            (--disable-anonymous)
                GF_AUTH_ANONYMOUS_ENABLED="false"
                ;;
            (--limit)
                LIMIT="1"
                ;;
            (--volume)
                LIMIT="1"
                VOLUME="1"
                ;;
            (--param)
                LIMIT="1"
                PARAM="1"
                ;;
            (--evaluation-interval)
                LIMIT="1"
                PARAM="evaluation-interval"
                ;;
            (--manager-agents)
                LIMIT="1"
                PARAM="manager-agents"
                ;;
            (--datadog-api-keys)
                LIMIT="1"
                PARAM="datadog-api-keys"
                ;;
            (--datadog-hostname)
                LIMIT="1"
                PARAM="datadog-hostname"
                ;;
            (--version)
                echo "Scylla-Monitoring Stack version: $CURRENT_VERSION"
    			echo "Supported versions:" ${SUPPORTED_VERSIONS[$BRANCH_VERSION]}
    			echo "Manager supported versions:" ${MANAGER_SUPPORTED_VERSIONS[$BRANCH_VERSION]}
    			exit 0
            (--no-cas-cdc)
                PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS --no-cas-cdc"
                ;;
            (--no-cas)
                PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS --no-cas"
                ;;
            (--no-cdc)
                PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS --no-cdc"
                ;;
            (--target-directory)
                LIMIT="1"
                PARAM="target-directory"
                ;;
            (--help) usage
                ;;
            (--archive)
                PROMETHEUS_COMMAND_LINE_OPTIONS_ARRAY+=(--storage.tsdb.retention.time=100y)
                ;;
            (*) set -- "$@" "$arg"
                ;;
        esac
    else
        DOCR=`echo $arg|cut -d',' -f1`
        VALUE=`echo $arg|cut -d',' -f2-|sed 's/#/ /g'`
        NOSPACE=`echo $arg|sed 's/ /#/g'`
        if [ "$PARAM" = "1" ]; then
            if [ -z "${DOCKER_PARAMS[$DOCR]}" ]; then
                DOCKER_PARAMS[$DOCR]=""
            fi
            DOCKER_PARAMS[$DOCR]="${DOCKER_PARAMS[$DOCR]} $VALUE"
            PARAMS="$PARAMS --param $NOSPACE"
            unset PARAM
        elif [ "$PARAM" = "evaluation-interval" ]; then
            PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS -E $NOSPACE"
            unset PARAM
        elif [ "$PARAM" = "manager-agents" ]; then
            SCYLLA_MANGER_AGENT_TARGET_FILE="$NOSPACE"
            unset PARAM
        elif [ "$PARAM" = "target-directory" ]; then
            TARGET_DIRECTORY="$NOSPACE"
            unset PARAM
        elif [ "$PARAM" = "datadog-api-keys" ]; then
            DATDOGPARAM="$DATDOGPARAM -A $NOSPACE"
            unset PARAM
        elif [ "$PARAM" = "datadog-hostname" ]; then
            DATDOGPARAM="$DATDOGPARAM -H $NOSPACE"
            unset PARAM
        else
            if [ -z "${DOCKER_LIMITS[$DOCR]}" ]; then
                DOCKER_LIMITS[$DOCR]=""
            fi
            if [ "$VOLUME" = "1" ]; then
                SRC=`echo $VALUE|cut -d':' -f1`
                DST=`echo $VALUE|cut -d':' -f2-`
                SRC=$($readlink_command "$SRC")
                DOCKER_LIMITS[$DOCR]="${DOCKER_LIMITS[$DOCR]} -v $SRC:$DST"
                VOLUMES="$VOLUMES --volume $NOSPACE"
                unset VOLUME
            else
                DOCKER_LIMITS[$DOCR]="${DOCKER_LIMITS[$DOCR]} $VALUE"
                LIMITS="$LIMITS --limit $NOSPACE"
            fi
        fi
        unset LIMIT
    fi
done

while getopts ':hleEd:g:p:v:s:n:a:c:j:b:m:r:R:M:G:D:L:N:C:Q:A:f:P:S:T:k:' option; do
  case "$option" in
    h) usage
       exit
       ;;
    v) VERSIONS=$OPTARG
       ;;
    M) MANAGER_VERSION=$OPTARG
       ;;
    d) DATA_DIR=$OPTARG
       ;;
    G) EXTERNAL_VOLUME="-G $OPTARG"
       ;;
    A) BIND_ADDRESS="$OPTARG:"
       ;;
    r) ALERT_MANAGER_RULE_CONFIG=$(set_path $OPTARG)
       ;;
    R) if [[ -d "$OPTARG" ]]; then
        PROMETHEUS_RULES=$($readlink_command $OPTARG)":/etc/prometheus/prom_rules/"
       else
        PROMETHEUS_RULES=$($readlink_command $OPTARG)":/etc/prometheus/prometheus.rules.yml"
       fi
       ;;
    g) GRAFANA_PORT="$OPTARG"
       ;;
    m) ALERTMANAGER_PORT="$OPTARG"
       ;;
    T) PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS -T $OPTARG"
       ;;
    Q) GF_AUTH_ANONYMOUS_ORG_ROLE="$OPTARG"
       ;;
    p) PROMETHEUS_PORT=$OPTARG
       ;;
    s) SCYLLA_TARGET_FILES=("$OPTARG")
       ;;
    n) NODE_TARGET_FILE=$OPTARG
       ;;
    l) DOCKER_PARAM="$DOCKER_PARAM    network_mode: host\n"
       ;;
    L) CONSUL_ADDRESS="-L $OPTARG"
       ;;
    P) LDAP_FILE="-P $OPTARG"
       ;;
    a) GF_SECURITY_ADMIN_PASSWORD="$OPTARG"
       ;;
    j) GRAFANA_DASHBOARD_ARRAY+=("$OPTARG")
       ;;
    c) GRAFANA_ENV_ARRAY+=("$OPTARG")
       ;;
    C) ALERTMANAGER_COMMANDS+=("$OPTARG")
       ;;
    D) DOCKER_PARAM="$DOCKER_PARAM    $OPTARG\n"
       ;;
    b) PROMETHEUS_COMMAND_LINE_OPTIONS_ARRAY+=("$OPTARG")
       ;;
    N) SCYLLA_MANGER_TARGET_FILES=($OPTARG)
       ;;
    S) SPECIFIC_SOLUTION="-S $OPTARG"
       ;;
    E) RUN_RENDERER="-E"
       ;;
    f) ALERT_MANAGER_DIR=( $(set_path $OPTARG):/alertmanager/data:z)
       ;;
    k) LOKI_DIR=`set_path $OPTARG`
       if [ ! -d $LOKI_DIR ]; then
           mkdir -p $LOKI_DIR
       fi
       LOKI_DIR="- $LOKI_DIR:/tmp/loki:z"
       ;;
    :) printf "missing argument for -%s\n" "$OPTARG" >&2
       echo "$usage" >&2
       exit 1
       ;;
   \?) printf "illegal option: -%s\n" "$OPTARG" >&2
       echo "$usage" >&2
       exit 1
       ;;
  esac
done

if [ -z "$VERSIONS" ]; then
  echo "Scylla-version was not not found, add the -v command-line with a specific version (i.e. -v 2021.1)"
  exit 1
fi

if [[ $DOCKER_PARAM = *"network_mode: host"* ]]; then
    if [ ! -z "$ALERTMANAGER_PORT" ] || [ ! -z "$GRAFANA_PORT" ] || [ ! -z $PROMETHEUS_PORT ]; then
        echo "Port mapping is not supported with host network, remove the -l flag from the command line"
        exit 1
    fi
    HOST_NETWORK=1
fi

if [ -z "$TARGET_DIRECTORY" ] && [ -z "$CONSUL_ADDRESS" ]; then
    for f in ${SCYLLA_TARGET_FILES[@]}; do
        if [ -f $f ]; then
            SCYLLA_TARGET_FILE=$f
            break
        fi
    done

    if [ -z $SCYLLA_TARGET_FILE ]; then
        echo "Scylla target file '${SCYLLA_TARGET_FILES}' does not exist, you can use prometheus/scylla_servers.example.yml as an example."
        exit 1
    fi

    if [ -z $NODE_TARGET_FILE ]; then
       PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS --no-node-exporter-file"
       NODE_TARGET_FILE=$SCYLLA_TARGET_FILE
    fi

    if [ -z $SCYLLA_MANGER_AGENT_TARGET_FILE ]; then
       PROMETHEUS_TARGETS="$PROMETHEUS_TARGETS --no-manager-agent-file"
       SCYLLA_MANGER_AGENT_TARGET_FILE=$SCYLLA_TARGET_FILE
    fi
    if [ ! -f $NODE_TARGET_FILE ]; then
        echo "Node target file '${NODE_TARGET_FILE}' does not exist"
        exit 1
    fi

    for f in ${SCYLLA_MANGER_TARGET_FILES[@]}; do
        if [ -f $f ]; then
            SCYLLA_MANGER_TARGET_FILE=$f
            break
        fi
    done
    if [ -z $SCYLLA_MANGER_TARGET_FILE ]; then
        echo "Scylla-Manager target file '${SCYLLA_MANGER_TARGET_FILES}' does not exist, you can use prometheus/scylla_manager_servers.example.yml as an example."
        exit 1
    fi
    if [ -z "$HOST_NETWORK" ]; then
        if  is_local $SCYLLA_TARGET_FILE $SCYLLA_MANGER_TARGET_FILE $NODE_TARGET_FILE; then
            echo "Warning: It seems that you are trying to connect to localhost (either localhost or IP on the 127.x.x.x range)."
            echo "  For example, maybe Scylla Manager is running on the localhost."
            echo "If that is the case, you should set your Docker to use the host network. You can do that with the -l flag."
            echo ""
        fi
    fi
    SCYLLA_TARGET_FILE=$(set_path $SCYLLA_TARGET_FILE):/etc/scylla.d/prometheus/targets/scylla_servers.yml
    SCYLLA_MANGER_TARGET_FILE=$(set_path $SCYLLA_MANGER_TARGET_FILE):/etc/scylla.d/prometheus/targets/scylla_manager_servers.yml
    NODE_TARGET_FILE=$(set_path $NODE_TARGET_FILE)":/etc/scylla.d/prometheus/targets/node_exporter_servers.yml"
    SCYLLA_MANGER_AGENT_TARGET_FILE=$(set_path $SCYLLA_MANGER_AGENT_TARGET_FILE)":/etc/scylla.d/prometheus/targets/scylla_manager_agents.yml"
else
    SCYLLA_TARGET_FILE=""
    SCYLLA_MANGER_TARGET_FILE=""
    SCYLLA_MANGER_AGENT_TARGET_FILE=""
    NODE_TARGET_FILE=""
fi

if [ "$TARGET_DIRECTORY" != "" ]; then
    SCYLLA_TARGET_FILE=$(set_path $TARGET_DIRECTORY)":/etc/scylla.d/prometheus/targets/"
fi
if [ -z $DATA_DIR ]
then
    PROMETHEUS_USER_PERMISSIONS=""
    echo "Warning: without an external Prometheus directory, Prometheus data will be deleted on shutdown, use the -d command line flag for data persistence."
else
    if [ -d $DATA_DIR ]; then
        echo "Loading prometheus data from $DATA_DIR"
    else
        echo "Creating data directory $DATA_DIR"
        mkdir -p $DATA_DIR
    fi
    if [[ "$VICTORIA_METRICS" = "1" ]]; then
    	PROMETHEUS_PROMETHEUS_VOLUMES_ARRAY+=($(set_path $DATA_DIR)":/victoria-metrics-data")
    else
        PROMETHEUS_PROMETHEUS_VOLUMES_ARRAY+=($(set_path $DATA_DIR)":/prometheus/data:Z")
    fi
fi

if (( ${#ALERTMANAGER_COMMANDS[@]} )); then
    ALERTMANAGER_COMMAND="    command:\n"`add_param "${ALERTMANAGER_COMMANDS[@]}"`
fi

if [ -z $PROMETHEUS_PORT ]; then
    PROMETHEUS_PORT=9090
fi
if [ -z $ALERTMANAGER_PORT ]; then
    ALERTMANAGER_PORT=9093
fi
if [ -z $GRAFANA_PORT ]; then
    GRAFANA_PORT=3000
fi
if [ -z $ANALYTICS_REPORTING_ENABLED ]; then
	ANALYTICS_REPORTING_ENABLED="false"
fi
if [ -z $ANALYTICS_CHECK_FOR_UPDATES ]; then
	ANALYTICS_CHECK_FOR_UPDATES="false"
fi
if [ -z $ANALYTICS_CHECK_FOR_PLUGIN_UPDATES ]; then
	ANALYTICS_CHECK_FOR_PLUGIN_UPDATES="false"
fi
if [ -z $SECURITY_ANGULAR_SUPPORT_ENABLED ]; then
	SECURITY_ANGULAR_SUPPORT_ENABLED="false"
fi
if [ -z $SERVER_ENABLE_GZIP ]; then
	SERVER_ENABLE_GZIP="true"
fi
DATA_SOURCES="-p aprom:$PROMETHEUS_PORT -m $ALERTMANAGER_ADDRESS -L loki:$LOKI_PORT"
ALERTMANAGER_ADDRESS="aalert:$ALERTMANAGER_PORT"
if [[ "$HOST_NETWORK" = "1" ]]; then
    ALERTMANAGER_ADDRESS="127.0.0.1:$ALERTMANAGER_PORT"
    DATA_SOURCES="-p 127.0.0.1:$PROMETHEUS_PORT -m $ALERTMANAGER_ADDRESS -L 127.0.0.1:$LOKI_PORT"
fi

if [[ ! -d $LOKI_WALL_DIR ]]; then
	echo "loki WALL directory does not exists"
fi

if [ -z $ALERT_MANAGER_RULE_CONFIG ]; then
	ALERT_MANAGER_RULE_CONFIG=./prometheus/rule_config.yml
fi
cat docker-compose.template.yml > docker-compose.yml
echo "" > .env
echo "PROMETHEUS_VERSION=$PROMETHEUS_VERSION" >> .env
echo "ALERT_MANAGER_VERSION=$ALERT_MANAGER_VERSION" >> .env
echo "GRAFANA_VERSION=$GRAFANA_VERSION" >> .env
echo "LOKI_VERSION=$LOKI_VERSION" >> .env
echo "GRAFANA_RENDERER_VERSION=$GRAFANA_RENDERER_VERSION" >> .env
echo "THANOS_VERSION=$THANOS_VERSION" >> .env
echo "VICTORIA_METRICS_VERSION=$VICTORIA_METRICS_VERSION" >> .env
echo "GF_AUTH_BASIC_ENABLED=$GF_AUTH_BASIC_ENABLED" >> .env
echo "GF_AUTH_ANONYMOUS_ENABLED=$GF_AUTH_ANONYMOUS_ENABLED" >> .env
echo "GF_AUTH_ANONYMOUS_ORG_ROLE=$GF_AUTH_ANONYMOUS_ORG_ROLE" >> .env
echo "GF_SECURITY_ADMIN_PASSWORD=$GF_SECURITY_ADMIN_PASSWORD" >> .env
echo "GF_ANALYTICS_REPORTING_ENABLED=$ANALYTICS_REPORTING_ENABLED" >> .env
echo "GF_ANALYTICS_CHECK_FOR_UPDATES=$ANALYTICS_CHECK_FOR_UPDATES" >> .env
echo "GF_ANALYTICS_CHECK_FOR_PLUGIN_UPDATES=$ANALYTICS_CHECK_FOR_PLUGIN_UPDATES" >> .env
echo "GF_SECURITY_ANGULAR_SUPPORT_ENABLED=$SECURITY_ANGULAR_SUPPORT_ENABLED" >> .env
echo "GF_SERVER_ENABLE_GZIP=$SERVER_ENABLE_GZIP" >> .env
echo "SCYLLA_VERSION=$VERSIONS" >> .env
echo "ALERTMANAGER_PORT=$ALERTMANAGER_PORT" >> .env
echo "GRAFANA_PORT=$GRAFANA_PORT" >> .env
echo "PROMETHEUS_PORT=$PROMETHEUS_PORT" >> .env
echo "ALERT_MANAGER_RULE_CONFIG=$ALERT_MANAGER_RULE_CONFIG" >> .env
echo "PROMETHEUS_RULES=$PROMETHEUS_RULES">> .env
echo "BIND_ADDRESS=$BIND_ADDRESS">> .env
echo "SCYLLA_TARGET_FILE=$SCYLLA_TARGET_FILE">> .env
echo "SCYLLA_MANGER_TARGET_FILE=$SCYLLA_MANGER_TARGET_FILE">> .env
echo "SCYLLA_MANGER_AGENT_TARGET_FILE=$SCYLLA_MANGER_AGENT_TARGET_FILE">> .env
echo "NODE_TARGET_FILE=$NODE_TARGET_FILE">> .env
echo "LOKI_RULE_DIR=$LOKI_RULE_DIR">> .env
echo "LOKI_CONF_DIR=$LOKI_CONF_DIR">> .env
echo "LOKI_DIR=$LOKI_DIR">> .env
echo "LOKI_PORT=$LOKI_PORT">> .env
echo "LOKI_WALL_DIR=$LOKI_WALL_DIR">> .env
if [ "$VICTORIA_METRICS" = "1" ]; then
	sed -i 's&prom/prometheus:${PROMETHEUS_VERSION}&victoriametrics/victoria-metrics:${VICTORIA_METRICS_VERSION}&' docker-compose.yml
	sed -i 's&./prometheus/build/prometheus.yml:/etc/prometheus/prometheus.yml&./prometheus/build/prometheus.yml:/etc/promscrape.config.yml:z&' docker-compose.yml
	PROMETHEUS_COMMAND_LINE_OPTIONS_ARRAY+=( -promscrape.config=/etc/promscrape.config.yml -promscrape.config.strictParse=false -httpListenAddr=:9090)
else
	PROMETHEUS_COMMAND_LINE_OPTIONS_ARRAY+=(--config.file=/etc/prometheus/prometheus.yml --web.enable-lifecycle)
fi
PROMETHEUS_COMMAND_LINE=""
if (( ${#PROMETHEUS_COMMAND_LINE_OPTIONS_ARRAY[@]} )); then
    PROMETHEUS_COMMAND_LINE="    command:\n"`add_param "${PROMETHEUS_COMMAND_LINE_OPTIONS_ARRAY[@]}"`
fi

sed -i "s& *#PROMETHEUS_COMMAND_LINE&$PROMETHEUS_COMMAND_LINE&" docker-compose.yml
val=`add_param "${PROMETHEUS_PROMETHEUS_VOLUMES_ARRAY[@]}"`
sed -i "s& *#PROMETHEUS_VOLUMES&$val&" docker-compose.yml

val=`add_param "${GRAFANA_ENV_ARRAY[@]}"`
sed -i "s& *#GRAFANA_ENV&$val&" docker-compose.yml

sed -i "s& *#GENERAL_DOCER_CONFIG&$DOCKER_PARAM&" docker-compose.yml
sed -i "s& *#ALERT_MANAGER_DIR&$ALERT_MANAGER_DIR&" docker-compose.yml
sed -i "s& *#ALERTMANAGER_COMMAND&$ALERTMANAGER_COMMAND&" docker-compose.yml
sed -i "s&#PROMETHEUS_USER_PERMISSIONS&$PROMETHEUS_USER_PERMISSIONS&" docker-compose.yml
sed -i "s&#LOKI_DIR&$LOKI_DIR&" docker-compose.yml
sed -i "s&#LOKi_USER_PERMISSIONS&$LOKi_USER_PERMISSIONS&" docker-compose.yml

./prometheus-config.sh -m $ALERTMANAGER_ADDRESS $CONSUL_ADDRESS $PROMETHEUS_TARGETS
for val in "${GRAFANA_DASHBOARD_ARRAY[@]}"; do
        GRAFANA_DASHBOARD_COMMAND="$GRAFANA_DASHBOARD_COMMAND -j $val"
done
./generate-dashboards.sh -t $SPECIFIC_SOLUTION -v $VERSIONS -M $MANAGER_VERSION $GRAFANA_DASHBOARD_COMMAND

./grafana-datasource.sh $DATA_SOURCES

if [ "$RUN_COMPOSE" = "1" ]; then
	docker-compose up
fi