startup.sh

#!/bin/bash
# set -e

show_help()
{
local ___script_name="$(basename "${0}")"
cat << EOF
DESCRIPTION:
 This script can be used for starting Frinx-Machine (FM) in specific modes.
  
  - If no options are specified, starts Workflow-Manager and UniConfig services on local single node 
    with development resources allocation and http protocol.

  - For starting FM in multi-node is need to generate uniconfig compose files with script:
    ./generate_uc_compose.sh --service-name <arg> --node-id <arg> --folder-path <arg>
    Then you can use ./startup.sh --multinode for start 
    For more info see './generate_uc_compose.sh -h' or README
                          
  - To use FM with production resource allocation settings, you can use own settings
    stored in ${productPerformSettingFile} or use predefined. 
    For enabling use --prod option. 
  
  For more info see README

OPTIONS:

 ${___script_name} [OPTIONS]

  FRINX-MACHINE CONFIGURATION

   --https       Deploy Frinx-Machine in https mode 
                  - KrakenD with certificates
                  - https://localhost
  
   --auth        Deploy Frinx-Machine with authorization

   --shell       Deploy Frinx-Machine with UC shell

   --prod|--dev|--high  
                  Deploy Frinx-Machine in production or development mode
                  - different allocation of resources
                  - default: production

   --workflow-manager  Deploy Workflow-Manager services
   --uniconfig         Deploy UniConfig services
   --unistore          Deploy Unistore services (not started by default)
   --with-unistore     Deploy Full FM with Unistore services
   --monitoring        Deploy Monitoring services
   --no-monitoring     Deploy Workflow-Manager and UniConfig services

   --with-kafka        Deploy FM with Kafka and Debezium connector


  MULTI-NODE DEPLOYMENT

   --multinode    <PATH>   Deploy FM in multinode mode
                            - Set path to folder witg Uniconfig compose files
                            - Default ${uniconfigServiceFilesPath}
                            - Workflow-Manager on manager node
                            - Uniconfig on worker nodes
                   
   For more info about multi-node deployment see README
                          
  COMMON SETTINGS

   -h|--help    Print this help and exit
   -d|--debug   Enable verbose

EOF
}


show_last_info()
{
echo -e "${INFO} Startup finished:"
cat << EOF
================================================================================

Use 'docker service ls' to check status of services.
Each service has REPLICAS 1/1 when everything works (it may take several minutes to start all services).

Use './teardown.sh' to stop all services
or  './teardown.sh -v' to remove also old data if needed.

EOF

echo -e "${INFO} USE localhost instead of 127.0.0.1"

}


function argumentsCheck {

  while [ $# -gt 0 ]
  do
    case "${1}" in
        -h|--help) show_help
           exit 0;;
        
        --https)
            export TLS_DISABLED="false"
            export KRAKEND_TLS_PROTOCOL="https"
            export KRAKEND_PORT=443;;

        --auth)
            export AUTH_ENABLED="true";;

        --shell)
            export UNICONFIG_SHELL_ENABLED="true";;

        --proxy)
            export PROXY_ENABLED="true"
            setProxyEnv;;


        --prod|--dev|--high)
            if [ -z ${__only_one_perf_config} ]; then
              if [ ${1} == "--prod" ]; then
                __only_one_perf_config="true"
                performSettings="${productPerformSettingFile}"
              elif [ ${1} == "--dev" ]; then
                __only_one_perf_config="true";
                performSettings="${devPerformSettingFile}"
              elif [ ${1} == "--high" ]; then
                __only_one_perf_config="true";
                performSettings="${highPerformSettingFile}"
              fi
            else 
                echo -e "Conflict parameters: --prod|--dev|--high !!! Just one can be selected !!!"
                echo -e "Use '${scriptName} --help' for more details"
                exit 1
            fi;;

        --workflow-manager|--uniconfig|--monitoring|--no-monitoring|--unistore|--with-unistore)
            if [ -z ${__only_one_config} ]; then
              if [ ${1} == "--workflow-manager" ]; then
                __only_one_config="true"
                startupType="workflow-manager"
              elif [ ${1} == "--uniconfig" ]; then
                __only_one_config="true"
                startupType="uniconfig"
              elif [ ${1} == "--monitoring" ]; then
                __only_one_config="true"
                startupType="monitoring"
              elif [ ${1} == "--no-monitoring" ]; then
                __only_one_config="true"
                startupType="nomonitoring"
              elif [ ${1} == "--unistore" ]; then
                __only_one_config="true"
                startupType="unistore"
              elif [ ${1} == "--with-unistore" ]; then
                __only_one_config="true"
                startupType="withunistore"
              fi
            else 
                echo -e "Conflict parameters: --workflow-manager|--uniconfig|--monitoring !!! Just one can be selected !!!"
                echo -e "Use '${scriptName} --help' for more details"
                exit 1
            fi;;
        
        --with-kafka)
          __kafka_deploy="true"
          export CONDUCTOR_OUTBOX_TABLE_ENABLED="true";;

        -m|--multinode)
            if [[ ${2} != '-'* ]] || [[ ${2} != '' ]]; then 
              if [[ -d ${2} ]]; then
                __multinode="true";
                # todo check is one or more uc composes exist
                uniconfigServiceFilesPath="${2}"
              else
                  echo -e "${ERROR} Wrong path to folder with uniconfig composefiles: '${2}'"
                  exit 1
              fi; shift
            fi;;

        -d|--debug) 
            set -x;;

        *) 
            echo -e "${ERROR} Unknown option: ${1}. See help!"
            exit 1;;
    esac
    shift
  done
}

function startMonitoring {
  echo -e "${INFO} Monitoring swarm node id: ${UF_SWARM_NODE_ID}"
  export TELEGRAF_GROUP=$(stat -c '%g' /var/run/docker.sock)
  export TELEGRAF_HOTNAME=$(stat -c '%g' /var/run/docker.sock)
  export HOSTNAME

  docker stack deploy --compose-file composefiles/$dockerSwarmMetrics $stackName
}

function startWorkflowManager {

  echo -e "${INFO} Workflow-Manager swarm worker node id: ${UF_SWARM_NODE_ID}"
  if [[ "$(docker service ls --format {{.Name}} | grep fm_unistore)" != "" ]]; then
    echo -e "${INFO} Update Frinx-Frontend: enable L3VPN automation"
    export L3VPN_ENABLED=true
  fi

  docker stack deploy --compose-file composefiles/$dockerSwarmWorkflowManager $stackName
  status=$?
  if [[ $status -ne 0 ]]; then
    echo -e "${ERROR} Problem with starting Workflow-Manager."
    echo -e "${ERROR} If 'network frinx-machine not found!', wait a while and start Workflow-Manager again."
    exit 1
  fi

  if [[ ${__kafka_deploy} == "true" ]]; then
    docker stack deploy --compose-file composefiles/$dockerSwarmWorkflowManagerKafka $stackName
  fi
  status=$?
  if [[ $status -ne 0 ]]; then
    echo -e "${ERROR} Problem with starting Workflow-Manager."
    echo -e "${ERROR} If 'network frinx-machine not found!', wait a while and start Workflow-Manager again."
    exit 1
  fi
}

function startUnistore {
  echo -e "${INFO} Update Frinx-Frontend and KrakenD: enable L3VPN automation"
  export L3VPN_ENABLED=true
  docker service update --env-add L3VPN_ENABLED=${L3VPN_ENABLED} fm_frinx-frontend  > /dev/null 2>&1
  docker service update --env-add L3VPN_ENABLED=${L3VPN_ENABLED} fm_krakend  > /dev/null 2>&1

  echo -e "${INFO} Unistore swarm worker node id: ${UF_SWARM_NODE_ID}"
  docker stack deploy --compose-file composefiles/$dockerSwarmUnistore $stackName
  status=$?
  if [[ $status -ne 0 ]]; then
    echo -e "${ERROR} Problem with starting Unistore."
    echo -e "${ERROR} If 'network frinx-machine not found!', wait a while and start FM again."
    exit 1
  fi
}

function startUniconfig {

  if [[ ${__multinode} == "true" ]]; then
    echo -e "${INFO} Multi-node deployment - compose files are stored on this path: ${uniconfigServiceFilesPath}"
    echo -e "${INFO} Make sure the UniConfig configuration files are present on remote node in /opt/frinx folder"
    shopt -s lastpipe
    find ${uniconfigServiceFilesPath} -iname "swarm-uniconfig.yml" -print0 | \
    while IFS= read -r -d '' compose_name; do 
      echo -e "${INFO} Checking swarm nodes for ${compose_name} uniconfig deployment"
      node_id="$(grep node "${compose_name}" | sed -e 's/^[[:space:]]*//')"
      checkUcSwarmMode "${node_id}"
      docker stack deploy --compose-file ${compose_name} $stackName    
    done
  else
    echo -e "${INFO} Single-node deployment - composefiles/${dockerSwarmUniconfig}"
    echo -e "${INFO} Uniconfig swarm worker node hostname: ${UC_SWARM_NODE_ID}"
    chmod -R 777  ${UF_CONFIG_PATH}/uniconfig/cache
    docker stack deploy --compose-file "composefiles/${dockerSwarmUniconfig}" $stackName
  fi
}

function startContainers {

  setUniconfigZoneEnv
  setNodeIdLocalDeploy
  
  case $startupType in
      workflow-manager)
        echo -e "${INFO} Deploying Workflow-Manager only"
        startWorkflowManager
      ;;

      uniconfig)
        echo -e "${INFO} Deploying Uniconfig only"
        startUniconfig
      ;;

      unistore)
        echo -e "${INFO} Deploying Unistore only"
        startUnistore
      ;;

      monitoring)
        echo -e "${INFO} Deploying Monitoring services only"
        startMonitoring
      ;;

      nomonitoring)
        echo -e "${INFO} Deploying Workflow-Manager and Uniconfig services only"
        startWorkflowManager
        startUniconfig
      ;;

      withunistore)
        echo -e "${INFO} Deploying Workflow-Manager, Uniconfig, Unistore and Monitoring services"
        startMonitoring
        startWorkflowManager
        startUniconfig
        startUnistore
      ;;

      full)
        echo -e "${INFO} Deploying Workflow-Manager, Uniconfig and Monitoring services"
        startMonitoring
        startWorkflowManager
        startUniconfig
      ;;

      *)
        echo -e "${ERROR} Unknown option: ${startupType}. See help!"
        exit 1
      ;;
  esac

}


function checkSuccess {
  if [[ $? -ne 0 ]]
  then
    echo -e "${ERROR} System is not healthy. Shutting down..."
    docker stack rm $stackName
    exit 1
  fi
}


function isNodeInSwarm {
  if [ -z "$(docker node ls | grep "${1}")" ]
  then
    echo -e "${ERROR} Node ${1} not in swarm for compose: ${2}!"
    docker swarm join-token worker
    exit 1
  else 
      if [[ ${__multi_uniconfig} == "true" ]]; then
        echo -e "${INFO} Service" ${2} "on swarm node id:" ${1}
      fi
  fi
}


function checkSwarmMode {
    if [ "$(docker info --format '{{.Swarm.LocalNodeState}}')" == "inactive" ]
    then
      echo -e "${ERROR} Docker not in swarm mode! Initialize the swarm first using 'docker swarm init'"
      echo -e "Exiting..."
      exit 1
    else
      echo -e "${INFO} Docker running in swarm mode"
    fi
}


function checkUcSwarmMode {

  local TYPE="$(echo ${1}| cut -d ' ' -f 2)"
  local PLACEMENT_INPUT="$(echo ${1}| cut -d ' ' -f 4)"
  if [[ $PLACEMENT_INPUT != '' ]] && [[ $TYPE != '' ]] ; then

    case $TYPE in
      'node.id')
        __id=($(docker node ls -f id=${PLACEMENT_INPUT} --format {{.ID}}))
        if [[ "${__id}" == "${PLACEMENT_INPUT}" ]];then
          __name=$(docker node ls -f id=${PLACEMENT_INPUT} --format {{.Hostname}})
          __status=$(docker node inspect ${__name} --format {{.Status.State}}) 
        else
          __name="node.id=${PLACEMENT_INPUT}"
          __status='not found' 
        fi;;

      'node.hostname')
        __name=($(docker node ls -f name=${PLACEMENT_INPUT} --format {{.Hostname}}))
        if [[ "${__name}" == "${PLACEMENT_INPUT}" ]];then
          __status=$(docker node inspect ${__name} --format {{.Status.State}}) 
        else
          __name="node.hostname=${PLACEMENT_INPUT}"
          __status='not found' 
        fi;;

      'node.labels.zone')
        __name=($(docker node ls -f node.label=zone --format {{.Hostname}})) || true
        if [[ "${__name}" != '' ]];then
          __status=$(docker node inspect ${__name} --format {{.Status.State}})
        else
          __name="node.label=${PLACEMENT_INPUT}"
          __status='not found' 
        fi;;

      'node.role')
        __name=($(docker node ls -f role=${PLACEMENT_INPUT} --format {{.Hostname}})) || true
        if [[ "${__name}" != '' ]];then
          __name=$(docker node ls -f role=${PLACEMENT_INPUT} --format {{.Hostname}})
          __status=$(docker node inspect ${__name} --format {{.Status.State}}) 
        else
          __name="node.role=${PLACEMENT_INPUT}"
          __status='not found' 
        fi;;
      *)
          echo -e "${ERROR} ${TYPE} is not supported"
          return;;
    esac
    
    if [[ "${__status}" != "ready" ]]; then
      echo -e "${ERROR} Swarm node:  ${__name} - ${__node_id} ${__status:-not exist}"
    elif [[ "${__status}" == "ready" ]]; then
      echo -e "${OK} Swarm node ${__name} with placement type ${TYPE} = ${PLACEMENT_INPUT} is ${__status}"
    fi
  fi

}


function checkSwarmNodeActive {
  local __node_id=${1}
  local __status=$(docker node ls --filter id=${__node_id} --format {{.Status}})
  local __name=$(docker node ls --filter id=${__node_id} --format {{.Hostname}})

  if [[ "${__status}" != "Ready" ]]; then
    echo -e "${ERROR} Swarm node:  ${__name} - ${__node_id} ${__status:-not exist}"
  elif [[ "${__status}" == "Ready" ]]; then
    echo -e "${OK} Swarm node:  ${__name} - ${__node_id} is ${__status}"
  fi
}


function setNodeIdLocalDeploy {
  if [ -z "${__multinode}" ]; then
    export UC_SWARM_NODE_ID="${nodeID}"
  fi
  export UF_SWARM_NODE_ID="${nodeID}"
}


function validateAzureAD {
  if [[ ${AUTH_ENABLED} == "false" ]]; then
    echo -e "${WARNING} For Authorization is used Frinx Fake Token"
  elif [[ ${AUTH_ENABLED} == "true" ]]; then
    echo -e "${WARNING} For Authorization is used Azure Active Directory"
  fi
}

function enableUcShell {
  if [[ ${UNICONFIG_SHELL_ENABLED} == "true" ]]; then
    echo -e "${WARNING} Exposing websocket proxy on port 8001"
    docker service update --publish-add mode=host,target=8001,published=8001 fm_krakend
  fi
}


function setUniconfigZoneEnv {

  if [[ ${__multinode} == "true" ]]; then
    shopt -s lastpipe
    find ${uniconfigServiceFilesPath} -iname "swarm-uniconfig.yml" -print0 | \
    while IFS= read -r -d '' traefik_name; do 
      if [[ -z $name ]]; then
        line_num=$(($(cat ${traefik_name} | grep -n "services:" | cut -d ':' -f 1)+1))
        name="$(sed -n ${line_num}p ${traefik_name} | cut -d ':' -f 1 | sed 's/ //g')" 
      else
        line_num=$(($(cat ${traefik_name} | grep -n "services:" | cut -d ':' -f 1)+1))
        name="$(sed -n ${line_num}p ${traefik_name} | cut -d ':' -f 1 | sed 's/ //g'),${name}"
      fi
    done
    name=${name}
  else
    name='uniconfig'
  fi
  export UNICONFIG_ZONES_LIST=${name}
}

function setProxyEnv {
  export HTTP_PROXY="${http_proxy:-$HTTP_PROXY}"
  export HTTPS_PROXY="${https_proxy:-$HTTPS_PROXY}"
  export NO_PROXY="$(echo ${no_proxy:-$NO_PROXY} | sed 's\ \\g')"

  # load .proxy settings
  setVariableFile "${stackProxyFile}"
  echo -e "${INFO} Proxy settings enabled!"
  echo -e "${INFO} http: ${HTTP_PROXY:-${WARNING}NaN}, https: ${HTTPS_PROXY:-${WARNING}NaN}, no: ${NO_PROXY:-${WARNING}NaN}"
}


function addEnvToFile {
  unset __old_env_var
  unset __new_env_var
  if [[ -f ${stackEnvFile} ]]; then
    if grep -Fq ${1} ${stackEnvFile}
    then
      __old_env_var=$(grep -n ^${1}= ${stackEnvFile} | cut -d':' -f1)
      __new_env_var="${1}=${2}"
      sed -i "${__old_env_var}d"  "${stackEnvFile}"
      __old_env_var=$((__old_env_var-1))
      sed -i "${__old_env_var}a ${__new_env_var}"  "${stackEnvFile}"
    else
      echo "${1}=${2}" >> ${stackEnvFile} 
    fi 
  fi
}


function setVariableFile {
  local __filePath="${1}"
  # check if the file exists and if contain at least one config parameter
  if [[ -f ${__filePath} ]] && [[ "$(grep -v '^\s*$\|^\s*\#' ${__filePath})" != "" ]]; then
    source "${__filePath}"
    local __name=$(grep ^[[:alpha:]] ${__filePath})
    for ((i=0; i< ${#__name[@]}; i++ ))
    do
      export $(echo "${__name[$i]}" | cut -d '=' -f1)
    done
  fi
}


function unsetVariableEnvFile {
  # check if the file exists and if contain at least one config parameter
  if [[ -f ${stackEnvFile} ]] && [[ "$(grep -v '^\s*$\|^\s*\#' ${stackEnvFile})" != "" ]]; then
    local __name=$(grep ^[[:alpha:]] ${stackEnvFile})
    for ((i=0; i< ${#__name[@]}; i++ ))
    do
      unset $(echo "${__name[$i]}" | cut -d '=' -f1)
    done
  fi
}

# =======================================
# Program starts here
# =======================================

# COMMON SETTINGS
scriptName="$(basename "${0}")"

FM_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
stackProxyFile="${FM_DIR}/.proxy"

ERROR="\033[0;31m[ERROR]:\033[0;0m"
WARNING="\033[0;33m[WARNING]:\033[0;0m"
INFO="\033[0;96m[INFO]:\033[0;0m"
OK="\033[0;92m[OK]:\033[0;0m"

# DEFAULT COMPOSE SETTINGS
stackName="fm"

dockerSwarmWorkflowManager='swarm-workflow-manager.yml'
dockerSwarmWorkflowManagerKafka='swarm-kafka-connector.yml'
dockerSwarmUniconfig='swarm-uniconfig.yml'
dockerSwarmUnistore='swarm-unistore.yml'

dockerSwarmMetrics='support/swarm-monitoring.yml'

uniconfigServiceFilesPath="${FM_DIR}/composefiles/uniconfig"

## Default http 
export TLS_DISABLED="true"
export KRAKEND_TLS_PROTOCOL="http"
export KRAKEND_PORT=80

## Default Auth settings
export AUTH_ENABLED=false

## Default UC SHELL settings
export UNICONFIG_SHELL_ENABLED=false

# DEFAULT PERFORM SETTINGS
devPerformSettingFile='./config/dev_settings.txt'
productPerformSettingFile='./config/prod_settings.txt'
highPerformSettingFile='./config/high_settings.txt'
performSettings="${productPerformSettingFile}"

# DEFAULT FM START SETTINGS
startupType="full"
nodeID=$(docker node ls --filter role=manager --format {{.Hostname}})
export UF_CONFIG_PATH="${FM_DIR}/config"
export DEPLOY_SETTINGS_TIMESTAMP=$(date +%s)

# =======================================
# FM starting
# =======================================

pushd ${FM_DIR} > /dev/null

argumentsCheck "$@"

checkSwarmMode
echo -e "${INFO} Selected resource configuration: ${performSettings}"

setVariableFile "${performSettings}"  # load performance settings
validateAzureAD

startContainers
enableUcShell
show_last_info
popd > /dev/null