#!/usr/bin/env bash

# ========================================================================
# Copyright (c) 2020-2024 Netcrest Technologies, LLC. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ========================================================================

SCRIPT_DIR="$(cd -P -- "$(dirname -- "$0")" && pwd -P)"

SLEEP_DELAY=2

if [ -f "$PADOGRID_HOME/$PRODUCT/bin_sh/.addonenv.sh" ] && [ -f "$SCRIPT_DIR/.argenv.sh" ]; then
   . $PADOGRID_HOME/$PRODUCT/bin_sh/.addonenv.sh
   IS_STANDALONE_SCRIPT="false"
else
   IS_STANDALONE_SCRIPT="true"
   FILE_SPECIFIED="false"
   FILE_ARG=""
   PRODUCT_SPECIFIED="false"
   PRODUCT_ARG=""
   QUIET="false" 
   NO_STTY_SPECIFIED="false"
   SCAN_SPECIFIED="false"
   SAVE_SPECIFIED="false"
   SAVE_ARG=""
   LOAD_SPECIFIED="false"
   LOAD_ARG=""
   SCAN_SPECIFIED="false"
   SCAN_ARG=""
   PREV=""
   for i in "$@"; do
      case $i in
         -quiet ) QUIET="true";;
         -product ) PRODUCT_SPECIFIED="true";;
         -file ) FILE_SPECIFIED="true";;
         -no-stty ) NO_STTY_SPECIFIED="true";;
         -scan ) SCAN_SPECIFIED="true";;
         -save ) SAVE_SPECIFIED="true";;
         -load ) LOAD_SPECIFIED="true";;
         -delay ) SCAN_SPECIFIED="true";;
         -version ) VERSION_SPECIFIED="true";;
         -?) HELP="true";;
         * ) 
            if [ "$PREV" == "-product" ]; then
               PRODUCT_ARG="$i";
            elif [ "$PREV" == "-file" ]; then
               FILE_ARG="$i";
            elif [ "$PREV" == "-save" ]; then
               SAVE_ARG="$i";
            elif [ "$PREV" == "-load" ]; then
               LOAD_ARG="$i";
            elif [ "$PREV" == "-scan" ]; then
               SCAN_ARG="$i";
            elif [ "$PREV" == "-version" ]; then
               VERSION_ARG="$i";
            else
               echo "Invalid option: [$i]. Command aborted."
               exit 1
            fi;;
      esac
      PREV="$i"
   done
fi

DOWNLOADABLE_PRODUCTS="padogrid pado padodesktop padoweb padoeclipse geode hazelcast-enterprise hazelcast-oss hazelcast-mc hazelcast-desktop redis-oss snappydata spark kafka confluent hadoop prometheus grafana-enterprise grafana-oss derby mosquitto"

EXECUTABLE="`basename $0`"

# 
# Determine the PadoGrid environment base path. Default is "$HOME/Padogrid". This maybe changed
# by the user if installing it for the first time in the interactive mode.
#
if [ "$PADOGRID_WORKSPACES_HOME" != "" ]; then
   PADOGRID_ENV_BASE_PATH="$(dirname $(dirname $PADOGRID_WORKSPACES_HOME))"
elif [ "$PADOGRID_ENV_BASE_PATH" == "" ]; then
   if [ "$PADOGRID_HOME" == "" ]; then
      PADOGRID_ENV_BASE_PATH="$HOME/Padogrid"
   fi
fi

#
# NOTE: To make this command independent, some of the functions defined in the file are duplicated
#       from the .utilenv.sh and .argenv.sh files.
#

if [ "$NO_COLOR" != "true" ]; then
   CNone='\033[0m' # No Color
   CBlue='\033[0;34m'
   CGo='\033[1;32m'
   CError='\033[1;31m'
   CUnderline='\033[4m'
   CUrl=$CBlue$CUnderline
fi

OS_NAME="$(uname -s | awk '{print tolower($0)}')"
HARDWARE_NAME="$(uname -m)"

DOWNLOAD_VERSIONS_URL="https://github.com/padogrid/padogrid/releases/download/nightly/padogrid_download_versions.sh"
PADOGRID_DOWNLOAD_URL="https://github.com/padogrid/padogrid/releases"
#PADO_DOWNLOAD_URL="https://github.com/netcrest/pado2/releases"
PADO_DOWNLOAD_URL=$PADOGRID_DOWNLOAD_URL
PADODESKTOP_DOWNLOAD_URL=$PADOGRID_DOWNLOAD_URL
PADOWEB_DOWNLOAD_URL=$PADOGRID_DOWNLOAD_URL
PADOECLIPSE_DOWNLOAD_URL=$PADOGRID_DOWNLOAD_URL
GEODE_DOWNLOAD_URL="https://archive.apache.org/dist/geode/"
HAZELCAST_ENTERPRISE_DOWNLOAD_URL="https://hazelcast.jfrog.io/artifactory/download/hazelcast-enterprise"
HAZELCAST_OSS_DOWNLOAD_URL="https://hazelcast.com/open-source-projects/downloads/archives"
HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_URL="https://hazelcast.com/open-source-projects/downloads/archives/"
HAZELCAST_DESKTOP_DOWNLOAD_URL="https://github.com/netcrest/hazelcast-desktop/releases"
REDIS_DOWNLOAD_URL="https://github.com/redis/redis/releases"
SNAPPYDATA_DOWNLOAD_URL="https://github.com/TIBCOSoftware/snappydata/releases"
SPARK_DOWNLOAD_URL="https://archive.apache.org/dist/spark/"
KAFKA_DOWNLOAD_URL="https://archive.apache.org/dist/kafka/"
CONFLUENT_DOWNLOAD_URL="https://packages.confluent.io/archive/"
HADOOP_DOWNLOAD_URL="https://archive.apache.org/dist/hadoop/common/"
PROMETHEUS_DOWNLOAD_URL="https://github.com/prometheus/prometheus/releases"
GRAFANA_GITHUB_RELEASES_URL="https://github.com/grafana/grafana/releases"
GRAFANA_DOWNLOAD_URL="https://grafana.com/grafana/download?edition=enterprise&pg=get&plcmt=selfmanaged-box1-cta1${None}"
DERBY_DOWNLOAD_URL="https://archive.apache.org/dist/db/derby/"
MOSQUITTO_DOWNLOAD_URL="https://mosquitto.org/files/source/"

PADOECLIPSE_MANUAL_URL="https://github.com/padogrid/padogrid/wiki/Eclipse"

PADOGRID_DOWNLOADS_PATH="$PADOGRID_ENV_BASE_PATH/downloads"
PADOGRID_PRODUCTS_PATH="$PADOGRID_ENV_BASE_PATH/products"
PADOGRID_SNAPSHOTS_PATH="$PADOGRID_ENV_BASE_PATH/snapshots"
PADOGRID_WORKSPACES_PATH="$PADOGRID_ENV_BASE_PATH/workspaces"

__options()
{
   echo "-product -version -file -quiet -simulate -save -load -scan -?"
}

if [ "$OPTIONS" == "true" ]; then
   __options
   exit
fi

if [ "$HELP" == "true" ]; then
cat <<EOF

NAME
   $EXECUTABLE - Install Padogrid and downloable products

SYNOPSIS
   $EXECUTABLE [-product product_name] [-version product_version]
                    [file padogrid_distribution_file_path]
                    [-scan [scan_delay_in_seconds]]
                    [-save|-load file_path]
                    [-quiet] [-simulate] [-?]

DESCRIPTION
   Installs PadoGrid and downloadable products. This command downloads one or more selected products
   and installs them in the PadoGrid environment base directory. If the base directory is not
   specified then it defaults to $HOME/Padogrid.

   To download a single product, specify the '-product' option.

OPTIONS
   -product product_name
             Product to downlaod. The product name must be one of the following.

EOF
for i in $DOWNLOADABLE_PRODUCTS; do
   echo "             $i"
done
cat <<EOF

   -version product_version
             Product version to install. The product version number must exactly match the
             version number conventions used by PadoGrid.

   -file padogrid_distribution_file_path
             Installs the specified padogrid distribution file. This option overrides all
             other options and runs in the non-interactive mode.

   -simulate
             If specified, then it only simulates the download steps by printing the 'curl'
             commands.

   -scan [scan_delay_in_seconds]
             If specified, then it scans the product download sites to gather product versions.
             This may take over a minute to complete. Specify scan_delay_in_seconds to delay
             between GitHub URL scans to prevent the GitHub rate meter from rejecting repetitive
             URL scans. By default, if this option is not specified, then it uses the cached
             product versions downloaded from the PadoGrid site. The cached product versions are
             updated nightly.
             Default: $SLEEP_DELAY seconds

   -save file_path
             Saves the downloadble product versions to the specified file path. If the '-scan'
             option is specified then it saves the scanned product versions.

   -load file_path
             Loads the downloadable product versions defined in the specified file.

   -quiet
             If specified, then it runs in the non-internactive mode. By default, it installs all
             of the latest products if not installed and creates an RWE if it does not exist. Note
             that installing all the products may take up to a few minutes to complete depending
             on your network speed.

EOF
if [ "$MAN_SPECIFIED" == "false" ]; then
cat <<EOF
   Your current PadoGrid environment base directory path is

      $PADOGRID_ENV_BASE_PATH
EOF
fi
cat <<EOF

   The base directory has the following structure and contains all of PadoGrid files including workspaces.

      .
      $TTee downloads
      $TTee products
      $TTee snapshots
      $TLel workspaces

      - The 'downloads' directory contains the files downloaded by this command.
      - The 'products' directory contains the installed products.
      - The 'snapshots' directory contains PadoGrid snapshot versions.
      - The 'workspaces' directory contains PadoGrid RWEs and their workspaces.

   The following products are downlodable and you can install them using this command.

EOF

echo -e "      - PadoGrid                    ${CUrl}$PADOGRID_DOWNLOAD_URL${CNone}"
echo -e "      - Apache Geode                ${CUrl}$GEODE_DOWNLOAD_URL${CNone}"
echo -e "      - Hazelcast Enterprise        ${CUrl}$HAZELCAST_ENTERPRISE_DOWNLOAD_URL${CNone}"
echo -e "      - Hazelcst OSS                ${CUrl}$HAZELCAST_OSS_DOWNLOAD_URL${CNone}"
echo -e "      - Hazelcast Management Center ${CUrl}$HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_URL${CNone}"
echo -e "      - HazelcastDesktop            ${CUrl}$HAZELCAST_DESKTOP_DOWNLOAD_URL${CNone}"
echo -e "      - Redis OSS                   ${CUrl}$REDIS_DOWNLOAD_URL${CNone}"
echo -e "      - TIBCO SnappyData            ${CUrl}$SNAPPYDATA_DOWNLOAD_URL${CNone}"
echo -e "      - Apache Spark                ${CUrl}$SPARK_DOWNLOAD_URL${CNone}"
echo -e "      - Apache Kafka                ${CUrl}$KAFKA_DOWNLOAD_URL${CNone}"
echo -e "      - Kafka Confluent Platform    ${CUrl}$CONFLUENT_DOWNLOAD_URL${CNone}"
echo -e "      - Apache Hadoop               ${CUrl}$HADOOP_DOWNLOAD_URL${CNone}"
echo -e "      - Prometheus                  ${CUrl}$PROMETHEUS_DOWNLOAD_URL${CNone}"
echo -e "      - Grafana Enterprise/OSS      ${CUrl}$GRAFANA_DOWNLOAD_URL${CNone}"
echo -e "      - Apache Derby                ${CUrl}$DERBY_DOWNLOAD_URL${CNone}"
echo -e "      - Eclipse Mosquitto           ${CUrl}$MOSQUITTO_DOWNLOAD_URL${CNone}"

cat <<EOF
  
   Mosquitto installation downloads a source distribution which requires a manual build.
   The build instructions are provided in the following link as well as printed upon
   completion of installation.

EOF
echo -e "      ${CUrl}https://github.com/padogrid/padogrid/wiki/Installing-Building-Mosquitto${CNone}"

cat <<EOF

   If you prefer a binary distribution then you can manually download it from the following link.
   Note that binary distributions are limited to macOS, Ubuntu, and Windows. You will need to
   build for other OS's.

EOF

echo -e "      ${CUrl}https://mosquitto.org/download/${CNone}"

cat <<EOF

   The following products are not downlodable due to their sign-in requirements. You must manually
   download and install them. See the PadoGrid manual for instructions.

EOF

echo -e "      - Oracle Coherence     ${CUrl}https://www.oracle.com/middleware/technologies/coherence-downloads.html${CNone}"
echo -e "      - TIBCO ComputeDB      ${CUrl}https://edelivery.tibco.com/storefront/index.ep${CNone}"
echo -e "      - Redis Enterprise     ${CUrl}https://redis.com/redis-enterprise-software/download-center/software/${CNone}"
echo -e "      - Redis Stack          ${CUrl}https://redis.io/download/${CNone}"
echo -e "      - VMware Tanzu GemFire ${CUrl}https://network.pivotal.io/products/pivotal-gemfire${CNone}"

cat <<EOF

   This command does not install Java. It expects that you have already installed JDK 1.8+ and prompts for
   the JAVA_HOME path. If you haven't installed it, then you can download it from one of the following sites.

EOF

echo -e "      - Oracle JDK              ${CUrl}https://www.oracle.com/java/technologies/javase-downloads.html${CNone}"
echo -e "      - Oracle Reference JDK    ${CUrl}https://jdk.java.net/${CNone}"
echo -e "      - Azule OpenJDK           ${CUrl}https://www.azul.com/downloads/${CNone}"
echo -e "      - Adoptium OpenJDK        ${CUrl}https://adoptium.net/${CNone}"
echo -e "      - Amazon Corretto OpenJDK ${CUrl}https://aws.amazon.com/corretto${CNone}"

cat <<EOF

   PadoGrid apps and bundles require Maven 3.x and may require the 'jq' executable. You can install them as
   packages or download them from the following links.

EOF

echo -e "      - Maven 3.x ${CUrl}https://maven.apache.org/download.cgi${CNone}"
echo -e "      - jq        ${CUrl}https://jqlang.github.io/jq/download/${CNone}"

cat <<EOF

NOTES
   - Derby distributions have the following Java version dependencies.
     - Java 17+ - 10.16.x.x
     - Java 9+ - 10.15.x.x
     - Java 8+ - 10.14.x.x, 10.13.x.x

   - PadoGrid support for Kafka is limited to the RAFT mode which requires Kafka 2.8.0+ or Confluent 7.0.0+.

   - PadoEclipse is an Eclipse plugin for generating Gedoe/GemFire and Pado data classes. Once it is
     downloaded, place it in the Eclipse's 'dropins' folder. Please see instructions in the following link.

EOF

echo -e "     ${CUrl}$PADOECLIPSE_MANUAL_URL${CNone}"
echo ""

if [ "$IS_STANDALONE_SCRIPT" == "false" ]; then
echo "SEE ALSO"
   printSeeAlsoList "show_padogrid uninstall_padogrid update_padogrid" $EXECUTABLE
fi
   exit
fi

#
# Returns "true" if the specified space-separated string contains the specified word.
# @param string   Space-speparated string
# @param word     Word to search in the specified string
#
function containsWord
{
   local string="$1"
   local word="$2"
   local retval="false"
   for i in $string; do
      if [ "$i" == "$word" ]; then
         retval="true"
         break;
      fi
    done
    echo "$retval"
}

# Exit if the user lacks download permissions
if [ -d "$PADOGRID_ENV_BASE_PATH" ] && [ ! -w "$PADOGRID_ENV_BASE_PATH" ]; then
   echo -e "${CError}ERROR:${CNone} Product installation denied. You do not have write permissions. Command aborted."
   exit 1
fi
if [ -d "$PADOGRID_PRODUCTS_PATH" ] && [ ! -w "$PADOGRID_PRODUCTS_PATH" ]; then
   echo -e "${CError}ERROR:${CNone} Product installation denied. You do not have write permissions. Command aborted."
   exit 1
fi
# Exit if both -save and -load specified
if [ "$SAVE_SPECIFIED" == "true" ] && [ "$LOAD_SPECIFIED" == "true" ]; then
   echo -e >&2 "${CError}ERROR:${CNone} Invalid options. '-load' and '-save' are not allowed together. Command aborted."
   exit 1
fi
# Exit if both -scan and -save specified
if [ "$SCAN_SPECIFIED" == "true" ] && [ "$LOAD_SPECIFIED" == "true" ]; then
   echo -e >&2 "${CError}ERROR:${CNone} Invalid options. '-scan' and '-load' are not allowed together. Command aborted."
   exit 1
fi
# Exit if both -product and -file specified
if [ "$PRODUCT_SPECIFIED" == "true" ] && [ "$FILE_SPECIFIED" == "true" ]; then
   echo -e >&2 "${CError}ERROR:${CNone} Invalid options. '-product' and '-file' are not allowed together. Command aborted."
   exit 1
fi
# Exit if invalid product specified
if [ "$PRODUCT_ARG" != "" ]; then
   if [ "$(containsWord "$DOWNLOADABLE_PRODUCTS" "$PRODUCT_ARG")" == "false" ]; then
      echo -e >&2 "${CError}ERROR:${CNone} Invalid product name: [$PRODUCT_ARG]. Please enter one of the following products."
      for i in $DOWNLOADABLE_PRODUCTS; do
         echo >&2 "          $i"
      done
      echo >&2 "       Command aborted."
      exit 1
   fi
fi
# Exit if invalid save option specified
if [ "$SAVE_SPECIFIED" == "true" ]; then
   DOWNLOAD_VERSIONS_FILE="$SAVE_ARG"
   if [ "$SAVE_ARG" == "" ] || [[ "$SAVE_ARG" == "-"** ]]; then
      echo -e >&2 "${CError}ERROR:${CNone} Invalid save option: [$SAVE_ARG]. Please enter file name."
      echo >&2 "       Command aborted."
      exit 1
   fi
fi
# Exit if invalid load option specified
if [ "$LOAD_SPECIFIED" == "true" ]; then
   DOWNLOAD_VERSIONS_FILE="$LOAD_ARG"
   if [ "$LOAD_ARG" == "" ] || [[ "$LOAD_ARG" == "-"** ]]; then
      echo -e >&2 "${CError}ERROR:${CNone} Invalid load option: [$LOAD_ARG]. Please enter file name."
      echo >&2 "       Command aborted."
      exit 1
   elif [ ! -f "$DOWNLOAD_VERSIONS_FILE" ]; then
      echo -e >&2 "${CError}ERROR:${CNone} Invalid file: [$DOWNLOAD_VERSIONS_FILE]. Please enter a valid file name."
      echo >&2 "       Command aborted."
      exit 1
   fi
fi

# Use the default scan delay if SCAN_ARG is not a number
if [ "$SCAN_ARG" != "" ]; then
   if [ -n "$SCAN_ARG" ] && [ "$SCAN_ARG" -eq "$SCAN_ARG" ] 2>/dev/null; then
      SLEEP_DELAY=$SCAN_ARG
   fi
fi

cat <<EOF

This command installs the following downlodable products:

EOF

echo -e "[0]  PadoGrid                    ${CUrl}$PADOGRID_DOWNLOAD_URL${CNone}"
echo -e "[1]  Apache Geode                ${CUrl}$GEODE_DOWNLOAD_URL${CNone}"
echo -e "[2]  Hazelcast Enterprise        ${CUrl}$HAZELCAST_ENTERPRISE_DOWNLOAD_URL${CNone}"
echo -e "[3]  Hazelcst OSS                ${CUrl}$HAZELCAST_OSS_DOWNLOAD_URL${CNone}"
echo -e "[4]  Hazelcast Management Center ${CUrl}$HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_URL${CNone}"
echo -e "[5]  HazelcastDesktop            ${CUrl}$HAZELCAST_DESKTOP_DOWNLOAD_URL${CNone}"
echo -e "[8]  REDIS OSS                   ${CUrl}$REDIS_DOWNLOAD_URL${CNone}"
echo -e "[9]  TIBCO SnappyData            ${CUrl}$SNAPPYDATA_DOWNLOAD_URL${CNone}"
echo -e "[10] Apache Spark                ${CUrl}$SPARK_DOWNLOAD_URL${CNone}"
echo -e "[11] Apache Kafka                ${CUrl}$KAFKA_DOWNLOAD_URL${CNone}"
echo -e "[12] Kafka Confluent Platform    ${CUrl}$CONFLUENT_DOWNLOAD_URL${CNone}"
echo -e "[13] Apache Hadoop               ${CUrl}$HADOOP_DOWNLOAD_URL${CNone}"
echo -e "[14] Prometheus                  ${CUrl}$PROMETHEUS_DOWNLOAD_URL${CNone}"
echo -e "[15] Grafana Enterprise/OSS      ${CUrl}$GRAFANA_DOWNLOAD_URL${CNone}"
echo -e "[16] Apache  Derby               ${CUrl}$DERBY_DOWNLOAD_URL${CNone}"
echo -e "[17] Eclipse Mosquitto           ${CUrl}$MOSQUITTO_DOWNLOAD_URL${CNone}"

cat <<EOF

The following products are not included in this command due to their download sign-in requirements.
To install them, you must download them manually. Make sure to install them in the PadoGrid
products directory. See the PadoGrid manual for instructions.

EOF

echo -e "[1] Oracle Coherence     ${CUrl}https://www.oracle.com/middleware/technologies/coherence-downloads.html${CNone}"
echo -e "[2] Redis Enterprise     ${CUrl}https://redis.com/redis-enterprise-software/download-center/software/${CNone}"
echo -e "[3] Redis Stack          ${CUrl}https://redis.io/download/${CNone}"
echo -e "[4] TIBCO ComputeDB      ${CUrl}https://edelivery.tibco.com/storefront/index.ep${CNone}"
echo -e "[5] VMware Tanzu GemFire ${CUrl}https://network.pivotal.io/products/pivotal-gemfire${CNone}"

cat <<EOF

Note that this command does not install Java. It expects that you have already installed JDK 1.8+ and
prompts for the JAVA_HOME path. If you haven't installed it, then you can download it from one of the
following sites.

EOF

echo -e "[0] Oracle JDK       ${CUrl}https://www.oracle.com/java/technologies/javase-downloads.html${CNone}"
echo -e "[1] Oracle OpenJDK   ${CUrl}https://jdk.java.net/${CNone}"
echo -e "[2] Azule OpenJDK    ${CUrl}https://www.azul.com/downloads/${CNone}"
echo -e "[3] Adoptium OpenJDK ${CUrl}https://adoptium.net/${CNone}"

function getLatestProductVersion
{
   local ALL_VERSIONS="$1"
   local lmajor=0
   local lminor=0
   local lupdate=-1
   for i in $ALL_VERSIONS; do
      local periods="${i//[^\.]}"
      local period_count=${#periods}
      if [ $period_count -eq 2 ]; then
         local major=${i%%\.*}
         local minor=${i%\.*}
         local minor=${minor#*\.}
         local update=${i##*\.}
      else
         local major=${i%%\.*}
         local minor=${i#*\.}
         local update=-1
      fi
      # echo debug: lmajor=$lmajor, lminor=$lminor, lupdate=$lupdate
      if [ $lmajor -lt $major ]; then
        lmajor=$major
        lminor=$minor
        lupdate=$update
      elif [ $lmajor -eq $major ]; then
        if [ "$(isNumber $minor)" == "true" ]; then
           if [ $lminor -lt $minor ]; then
              lminor=$minor
              lupdate=$update
           elif [ $lminor -eq $minor ]; then
              if [ $lupdate == "-1" ]; then
                 lupdate=$update
              elif [ "$(isNumber $lupdate)" == "true" ] && [ "$(isNumber $update)" == "true" ]; then
                 if [ $lupdate -lt $update ]; then
                    lupdate=$update
                 fi
              else
                 lupdate=$update
              fi
           fi
        fi
      fi
   done
   if [ $lupdate == "-1" ]; then
      echo "$lmajor.$lminor"
   else
      echo "$lmajor.$lminor.$lupdate"
   fi
}

#
# Returns trimmed string
# @param String to trim
#
function trimString
{
    local var="$1"
    # remove leading whitespace characters
    var="${var#"${var%%[![:space:]]*}"}"
    # remove trailing whitespace characters
    var="${var%"${var##*[![:space:]]}"}"   
    echo -n "$var"
}

#
# Returns a string list with all duplicate words removed from the specified string list.
# @param stringList String list of words separated by spaces
#
function unique_words
{
   local __words=$1
   local  __resultvar=$2
   local __visited
   local __unique_words
   local __i
   local __j

   # remove all repeating hosts
   for __i in $__words; do
      __visited=false
      for __j in $__unique_words; do
         if [ "$__i" == "$__j" ]; then
            __visited=true
         fi
      done
      if [ "$__visited" == "false" ]; then
         __unique_words="$__unique_words $__i"
      fi
   done

   if [[ "$__resultvar" ]]; then
      eval $__resultvar="'$__unique_words'"
      #echo `trimString "$__resultvar"`
   else
     echo `trimString "$__unique_words"`
   fi
}

function getDownloadablePadogridVersions
{
   local is_next_page="true"
   local page=1
   local ALL_PADOGRID_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${PADOGRID_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "padogrid_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' -e 's/\.tar\.gz.*//' -e 's/\/padoweb.*//' -e 's/\/pado_.*//' -e 's/\/pado\-desktop.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -s $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url  |grep "padogrid_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' -e 's/\.tar\.gz.*//' -e 's/\/padoweb.*//' -e 's/\/pado_.*//' -e 's/\/pado\-desktop.*//')
               versions=$(unique_words "$versions")
               ALL_PADOGRID_VERSIONS="$ALL_PADOGRID_VERSIONS $versions"
            done
         fi
      else
         ALL_PADOGRID_VERSIONS="$ALL_PADOGRID_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_PADOGRID_VERSIONS"
}

function getDownloadablePadoVersions
{
   local is_next_page="true"
   local page=1
   local ALL_PADO_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${PADO_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "pado_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' | grep "\/pado_.*" | sed -e 's/\.tar\.gz.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -s $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url  | grep "pado_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' | grep "\/pado_.*" | sed -e 's/\.tar\.gz.*//')
               if [ "$versions" != "" ]; then
                  ALL_PADO_VERSIONS="$ALL_PADO_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_PADO_VERSIONS="$ALL_PADO_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_PADO_VERSIONS"
}

function getDownloadablePadowebVersions
{
   local is_next_page="true"
   local page=1
   local ALL_PADOWEB_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${PADOWEB_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "padoweb_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' | grep "\/padoweb_.*" | sed -e 's/\.tar\.gz.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -s $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url  | grep "padoweb_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' | grep "\/padoweb_.*" | sed -e 's/\.tar\.gz.*//')
               if [ "$versions" != "" ]; then
                  ALL_PADOWEB_VERSIONS="$ALL_PADOWEB_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_PADOWEB_VERSIONS="$ALL_PADOWEB_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_PADOWEB_VERSIONS"
}

function getDownloadablePadodesktopVersions
{
   local is_next_page="true"
   local page=1
   local ALL_PADODESKTOP_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${PADODESKTOP_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "pado-desktop_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' | grep "\/pado-desktop_.*" | sed -e 's/\.tar\.gz.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -sL $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url | grep "pado-desktop_" | grep '\.tar\.gz' | sed -e 's/.*padogrid_//' | grep "\/pado-desktop_.*" | sed -e 's/\.tar\.gz.*//')
               if [ "$versions" != "" ]; then
                  ALL_PADODESKTOP_VERSIONS="$ALL_PADODESKTOP_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_PADODESKTOP_VERSIONS="$ALL_PADODESKTOP_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_PADODESKTOP_VERSIONS"
}

function getDownloadablePadoEclipseVersions
{
   local is_next_page="true"
   local page=1
   local ALL_PADOECLIPSE_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${PADOECLIPSE_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "com.netcrest.pado.eclipse_" | grep '\.jar' |  sed -e 's/.*padogrid_//' |  grep "\/com.netcrest.pado.eclipse_.*" | sed -e 's/\.jar.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -sL $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url  | grep "com.netcrest.pado.eclipse_" | grep '\.jar' |  sed -e 's/.*padogrid_//' |  grep "\/com.netcrest.pado.eclipse_.*" | sed -e 's/\.jar.*//')
               if [ "$versions" != "" ]; then
                  ALL_PADOECLIPSE_VERSIONS="$ALL_PADOECLIPSE_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_PADOECLIPSE_VERSIONS="$ALL_PADOECLIPSE_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_PADOECLIPSE_VERSIONS"
}
 
function getDownloadableGeodeVersions
{
   local ALL_GEODE_VERSIONS=$(curl -sL $GEODE_DOWNLOAD_URL |grep img | grep -v unknown | grep -v incubating | sed -e 's/.*>1./1./' -e 's/\/.*//' | grep -v img)
   unique_words "$ALL_GEODE_VERSIONS"
}

function getDownloadableHazelcastEnterpriseVersions
{
   local ALL_HAZELCAST_ENTERPRISE_VERSIONS=$(curl -sL $HAZELCAST_ENTERPRISE_DOWNLOAD_URL | grep .tar.gz | sed -e 's/^.*hazelcast-enterprise-//' -e 's/.tar.gz.*//' -e '/href/d')
   unique_words "$ALL_HAZELCAST_ENTERPRISE_VERSIONS"
}

function getDownloadableHazelcastOssVersions
{
   local ALL_HAZELCAST_OSS_VERSIONS_5=$(curl -sL $HAZELCAST_OSS_DOWNLOAD_URL | grep "Platform 5" | sed -e 's/.*Platform 5/5/' -e 's/<.*//')
   local ALL_HAZELCAST_OSS_VERSIONS_5_SLIM=""
   for i in $ALL_HAZELCAST_OSS_VERSIONS_5; do
      ALL_HAZELCAST_OSS_VERSIONS_5_SLIM="$ALL_HAZELCAST_OSS_VERSIONS_5_SLIM $i-slim"
   done
   local ALL_HAZELCAST_OSS_VERSIONS_4=$(curl -sL $HAZELCAST_OSS_DOWNLOAD_URL | grep "IMDG 4" | sed -e 's/.*IMDG 4/4/' -e 's/<.*//')
   local ALL_HAZELCAST_OSS_VERSIONS_3=$(curl -sL $HAZELCAST_OSS_DOWNLOAD_URL | grep "IMDG 3" | sed -e 's/.*IMDG 3/3/' -e 's/<.*//')
   ALL_HAZELCAST_OSS_VERSIONS="$ALL_HAZELCAST_OSS_VERSIONS_5 $ALL_HAZELCAST_OSS_VERSIONS_5_SLIM $ALL_HAZELCAST_OSS_VERSIONS_4 $ALL_HAZELCAST_OSS_VERSIONS_3"
   unique_words "$ALL_HAZELCAST_OSS_VERSIONS"
}

function getDownloadableHazelcastManCenterVersions
{
   local ALL_HAZELCAST_MANAGEMENT_CENTER_VERSIONS=$(curl -sL $HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_URL | grep hazelcast-management-center | grep "tar.gz" |  sed -e 's/.*hazelcast-management-center-//' -e 's/\.tar\.gz.*//')
   unique_words "$ALL_HAZELCAST_MANAGEMENT_CENTER_VERSIONS"
}

function getDownloadableHazelcastDesktopVersions
{
   local is_next_page="true"
   local page=1
   local ALL_HAZELCAST_DESKTOP_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${HAZELCAST_DESKTOP_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -s $download_url | grep "hazelcast-desktop_" | grep '\.tar\.gz' | sed -e 's/.*hazelcast-desktop_//' -e 's/\.tar\.gz.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -sL $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url  | grep "hazelcast-desktop_" | grep '\.tar\.gz' | sed -e 's/.*hazelcast-desktop_//' -e 's/\.tar\.gz.*//')
               if [ "$versions" != "" ]; then
                  ALL_HAZELCAST_DESKTOP_VERSIONS="$ALL_HAZELCAST_DESKTOP_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_HAZELCAST_DESKTOP_VERSIONS="$ALL_HAZELCAST_DESKTOP_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_HAZELCAST_DESKTOP_VERSIONS"
}

function getDownloadableRedisVersions
{
   local is_next_page="true"
   local page=1
   local ALL_REDIS_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${REDIS_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url |  grep '\.tar\.gz' | sed -e 's/\.tar.*$//' -e 's/.*\///')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -s $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            versions=$(echo $assets_urls | sed 's/http:.*expanded_assets//g')
            for url in $assets_urls; do
               versions=$(echo $url | sed 's|.*expanded_assets/||')
               # The following check tar ball - not necessary, takes long time
               # versions=$(curl -sL $url |  grep '\.tar\.gz' | sed -e 's/\.tar.*$//' -e 's/.*\///')
               if [ "$versions" != "" ]; then
                  ALL_REDIS_VERSIONS="$ALL_REDIS_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_REDIS_VERSIONS="$ALL_REDIS_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_REDIS_VERSIONS"
}

function getDownloadableSnappyDataVersions
{
   local is_next_page="true"
   local page=1
   local ALL_SNAPPYDATA_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${SNAPPYDATA_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "snappydata-" | grep "tar.gz" | grep -v ec2 | sed -e 's/.*snappydata-//' -e 's/\.tar\.gz.*//')
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      if [ "$PAGE_VERSIONS" == "" ]; then
         local assets_urls=$(curl -s $download_url | grep "expanded_assets" | sed -e 's/^.*src="//g' -e 's/".*$//')
         if [ "$assets_urls" == "" ]; then
            is_next_page="false"
         else
            for url in $assets_urls; do
               versions=$(curl -sL $url  | grep "snappydata-" | grep "tar.gz" | grep -v ec2 | sed -e 's/.*snappydata-//' -e 's/\.tar\.gz.*//')
               if [ "$versions" != "" ]; then
                  ALL_SNAPPYDATA_VERSIONS="$ALL_SNAPPYDATA_VERSIONS $versions"
               fi
            done
         fi
      else
         ALL_SNAPPYDATA_VERSIONS="$ALL_SNAPPYDATA_VERSIONS $PAGE_VERSIONS"
      fi
      let page=page+1

      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_SNAPPYDATA_VERSIONS"
}

function getDownloadableSparkVersions
{
   local ALL_SPARK_VERSIONS=$(curl -sL $SPARK_DOWNLOAD_URL | grep img | grep -v unknown | grep -v incubating  | grep -v preview |  sed -e 's/.*spark-/spark-/' -e 's/\/<.*//' -e 's/spark-//' | grep -v img)
   unique_words "$ALL_SPARK_VERSIONS"
}

function getPrebuiltSparkVersions
{
   local VERSION=$1
   local PREBUILT_SPARK_VERSIONS=$(curl -sL ${SPARK_DOWNLOAD_URL}spark-$VERSION/ | grep img | grep spark-$VERSION-bin | sed -e 's/.*spark-//' -e 's/.tgz.*//')
   unique_words "$PREBUILT_SPARK_VERSIONS"
}

function getDownloadableKafkaVersions
{
  local ALL_KAFKA_VERSIONS=$(curl -sL $KAFKA_DOWNLOAD_URL |grep img |grep -v unknown | grep -v incubating  | grep -v preview | grep -v kafka |grep -v Parent |grep -v old_releases | grep \[DIR\] | grep -v TXT | sed -e 's/.*href.*\/">//' -e 's/\/.*$//')
   unique_words "$ALL_KAFKA_VERSIONS"
}

function getScalaKafkaVersions
{
   local VERSION=$1
   local SCALA_KAFKA_VERSIONS=$(curl -sL ${KAFKA_DOWNLOAD_URL}/$VERSION/ | grep img | grep "kafka_.*$VERSION.tgz" | sed -e 's/.*kafka_//' -e 's/\.tgz.*$//')
   unique_words "$SCALA_KAFKA_VERSIONS"
}

function getDownloadableConfluentVersions
{
   local MINOR_VERSIONS=$(curl -sL ${CONFLUENT_DOWNLOAD_URL} | grep href | grep archive | sed -e 's/.*">//' -e 's/\/.*//')
   local ALL_CONFLUENT_VERSIONS
   for i in $MINOR_VERSIONS; do
      local MAJOR_VERSION=$(echo $i | awk -F. '{printf "%s", $1}')
      # KRaft supported startingetDownloadableConfluentVersionsg 7.0
      if [ $MAJOR_VERSION -ge 6 ]; then
         local versions=$(curl -sL ${CONFLUENT_DOWNLOAD_URL}$i/ | grep "confluent-.*.tar.gz<" | grep -v zOS | sed -e 's/.*>confluent/confluent/' -e 's/.tar.gz.*//')
         ALL_CONFLUENT_VERSIONS="$ALL_CONFLUENT_VERSIONS $versions"
      fi
   done
   unique_words "$ALL_CONFLUENT_VERSIONS"
}

function getDownloadableHadoopVersions
{
  local ALL_HADOOP_VERSIONS=$(curl -sL $HADOOP_DOWNLOAD_URL | grep img | grep -v unknown | grep -v incubating  | grep -v preview |grep \[DIR\] | grep -v Parent | grep -v TXT | grep hadoop | sed -e 's/.*href.*\/">//' -e 's/\/.*$//' -e 's/hadoop-//')
   unique_words "$ALL_HADOOP_VERSIONS"
}

function getDownloadablePrometheusVersions
{
   local is_next_page="true"
   local page=1
   local ALL_PROMETHEUS_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${PROMETHEUS_DOWNLOAD_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "/prometheus/prometheus/tree/v" | sed -e 's|^.*/prometheus/prometheus/tree/v||' -e 's/".*$//')
      #is_next_page="$([ "$PAGE_VERSIONS" != "" ] && echo "true" || echo "false")"
      is_next_page="$([ $page -lt 2 ] && echo "true" || echo "false")"
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      ALL_PROMETHEUS_VERSIONS="$ALL_PROMETHEUS_VERSIONS $PAGE_VERSIONS"
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_PROMETHEUS_VERSIONS"
}

function getDownloadableGrafanaVersions
{
   local is_next_page="true"
   local page=1
   local ALL_GRAFANA_VERSIONS=""
   while [ "$is_next_page" == "true" ]; do
      download_url="${GRAFANA_GITHUB_RELEASES_URL}?page=$page"
      local PAGE_VERSIONS=$(curl -sL $download_url | grep "/grafana/grafana/tree/v" | sed -e 's|^.*/grafana/grafana/tree/v||' -e 's/".*$//')
      #is_next_page="$([ "$PAGE_VERSIONS" != "" ] && echo "true" || echo "false")"
      is_next_page="$([ $page -lt 2 ] && echo "true" || echo "false")"
      PAGE_VERSIONS=$(unique_words "$PAGE_VERSIONS")
      ALL_GRAFANA_VERSIONS="$ALL_GRAFANA_VERSIONS $PAGE_VERSIONS"
      let page=page+1
      # Wait a bit to reset the GitHub rate meter
      sleep $SLEEP_DELAY
   done
   unique_words "$ALL_GRAFANA_VERSIONS"
}

function getDownloadableDerbyVersions
{
   local ALL_DERBY_VERSIONS=$(curl -sL $DERBY_DOWNLOAD_URL | grep img | grep db-derby- | grep -v current |  sed -e 's/^.*">//' -e 's/\/.*$//')
   unique_words "$ALL_DERBY_VERSIONS"
}

function getDownloadableMosquittoVersions
{
   local ALL_MOSQUITTO_VERSIONS=$(curl -sL $MOSQUITTO_DOWNLOAD_URL | grep .tar.gz | sed -e 's|.tar.gz.*||' -e 's|.*ref="||' -e 's|mosquitto-||' | uniq)
   unique_words "$ALL_MOSQUITTO_VERSIONS"
}

#
# Returns the sorted list of the specified list that contains product versions
# @param versionList
#
function sortVersionList
{
   local VERSION_LIST="$1"
   local TMP_FILE=/tmp/$EXECUTABLE-$(date "+%m%d%y%H%M%S").txt
   echo 
   echo "" > $TMP_FILE
   if [ -f $TMP_FILE ]; then
      rm $TMP_FILE
   fi
   touch $TMP_FILE
   for i in $VERSION_LIST; do
      echo "$i" >> $TMP_FILE
   done
   
   # The -V option may not be available for some OS's.
   SORTED_VERSIONS=$(sort -rV $TMP_FILE 2> /dev/null)
   case ${?} in
   0) echo ;;
   *) SORTED_VERSIONS=$(sort -r $TMP_FILE) ;;
   esac
   rm $TMP_FILE
   echo $SORTED_VERSIONS
}

#
# Determines versions of all installed products by scanning the products base directory.
# This function sets the following arrays.
#    PADOGRID_VERSIONS
#    PADO_VERSIONS
#    PADODESKTOP_VERSIONS
#    PADOWEB_VERSIONS
#    GEMFIRE_VERSIONS
#    GEODE_VERSIONS
#    HAZELCAST_ENTERPRISE_VERSIONS
#    HAZELCAST_OSS_VERSIONS
#    HAZELCAST_MANAGEMENT_CENTER_VERSIONS
#    HAZELCAST_DESKTOP_VERSIONS
#    REDIS_VERSIONS
#    SNAPPYDATA_VERSIONS
#    SPARK_VERSIONS
#    KAFKA_VERSIONS
#    CONFLUENT_VERSIONS
#    HADOOP_VERSIONS
#    PROMETHEUS_VERSIONS
#    GRAFANA_ENTERPRISE_VERSIONS
#    GRAFANA_OSS_VERSIONS
#    DERBY_VERSIONS
#    MOSQUITTO_VERSIONS
#
# @required PADOGRID_ENV_BASE_PATH 
#
function determineInstalledProductVersions
{
   PADOGRID_VERSIONS=""
   PADO_VERSIONS=""
   PADODESKTOP_VERSIONS=""
   PADOWEB_VERSIONS=""
   GEMFIRE_VERSIONS=""
   GEODE_VERSIONS=""
   HAZELCAST_ENTERPRISE_VERSIONS=""
   HAZELCAST_OSS_VERSIONS=""
   HAZELCAST_MANAGEMENT_CENTER_VERSIONS=""
   HAZELCAST_DESKTOP_CENTER_VERSIONS=""
   REDIS_VERSIONS=""
   SNAPPYDATA_VERSIONS=""
   SPARK_VERSIONS=""
   KAFKA_VERSIONS=""
   CONFLUENT_VERSIONS=""
   HADOOP_VERSIONS=""
   PROMETHEUS_VERSIONS=""
   GRAFANA_ENTERPRISE_VERSIONS=""
   GRAFANA_OSS_VERSIONS=""
   DERBY_VERSIONS=""
   MOSQUITTO_VERSIONS=""

   if [ -d "$PADOGRID_ENV_BASE_PATH/products" ]; then
      pushd $PADOGRID_ENV_BASE_PATH/products > /dev/null 2>&1

      # To prevent wildcard not expanding in a for-loop if files do not exist
      shopt -s nullglob

      local __versions
      local henterv hmanv jenterv jmanv jossv hossv

      # PadoGrid
      __versions=""
      for i in padogrid_*; do
         __version=${i#padogrid_}
         __versions="$__versions $__version "
      done
      PADOGRID_VERSIONS=$(sortVersionList "$__versions")

      # Pado
      __versions=""
      for i in pado_*; do
         __version=${i#pado_}
         __versions="$__versions $__version "
      done
      PADO_VERSIONS=$(sortVersionList "$__versions")

      # PadoDesktop
      __versions=""
      for i in pado-desktop_*; do
         __version=${i#pado-desktop_}
         __versions="$__versions $__version "
      done
      PADODESKTOP_VERSIONS=$(sortVersionList "$__versions")

      # PadoWeb
      __versions=""
      for i in padoweb_*; do
         __version=${i#padoweb_}
         __versions="$__versions $__version "
      done
      PADOWEB_VERSIONS=$(sortVersionList "$__versions")

      # GemFire
      __versions=""
      for i in pivotal-gemfire-*; do
         __version=${i#pivotal-gemfire-}
         __versions="$__versions $__version "
      done
      GEMFIRE_VERSIONS=$(sortVersionList "$__versions")

      # Geode
      __versions=""
      for i in apache-geode-*; do
         __version=${i#apache-geode-}
         __versions="$__versions $__version "
      done
      GEODE_VERSIONS=$(sortVersionList "$__versions")

      # Hazelcast OSS, Enterprise, Hazelcast Management Center
      local hossv henterv hmanv hdesktopv jossv jenterv jmanv
      for i in hazelcast-*; do
         if [[ "$i" == "hazelcast-enterprise-"** ]]; then
            __version=${i#hazelcast-enterprise-}
            henterv="$henterv $__version"
         elif [[ "$i" == "hazelcast-management-center-"** ]]; then
            __version=${i#hazelcast-management-center-}
            hmanv="$hmanv $__version"
         elif [[ "$i" == "hazelcast-desktop_"** ]]; then
            __version=${i#hazelcast-desktop_}
            hdesktopv="$hdesktopv $__version"
         elif [[ "$i" == "hazelcast-"** ]]; then
            __version=${i#hazelcast-}
            hossv="$hossv $__version"
         fi
      done

      HAZELCAST_ENTERPRISE_VERSIONS=$(sortVersionList "$henterv")
      HAZELCAST_MANAGEMENT_CENTER_VERSIONS=$(sortVersionList "$hmanv")
      HAZELCAST_DESKTOP_VERSIONS=$(sortVersionList "$hdesktopv")
      HAZELCAST_OSS_VERSIONS=$(sortVersionList "$hossv")

      # Redis
      __versions=""
      for i in redis-*; do
         __version=${i#redis-}
         __versions="$__versions $__version "
      done
      REDIS_VERSIONS=$(sortVersionList "$__versions")
      
      # SnappyData
      __versions=""
      for i in snappydata-*; do
         __version=${i#snappydata-}
         #__version=${__version%-bin}
         __versions="$__versions $__version "
      done
      SNAPPYDATA_VERSIONS=$(sortVersionList "$__versions")

      # Spark
      __versions=""
      for i in spark-*; do
         __version=${i#spark-}
         __version=${__version%-bin}
         __versions="$__versions $__version "
      done
      SPARK_VERSIONS=$(sortVersionList "$__versions")

      # Kafka
      __versions=""
      for i in kafka_*; do
         __version=${i#kafka_}
         __version=${__version%-bin}
         __versions="$__versions $__version "
      done
      KAFKA_VERSIONS=$(sortVersionList "$__versions")

      # Confluent
      __versions=""
      for i in confluent-*; do
         __version=${i#confluent-}
         __versions="$__versions $__version "
      done
      CONFLUENT_VERSIONS=$(sortVersionList "$__versions")

      # Hadoop
      __versions=""
      for i in hadoop-*; do
         __version=${i#hadoop-}
         __versions="$__versions $__version "
      done
      HADOOP_VERSIONS=$(sortVersionList "$__versions")
      
      # Prometheus
      __versions=""
      for i in prometheus-*; do
         __version=${i#prometheus-}
         __versions="$__versions $__version "
      done
      PROMETHEUS_VERSIONS=$(sortVersionList "$__versions")

      # Grafana OSS, Enterprise
      local gossv genterv
      for i in grafana-*; do
         if [[ "$i" == "grafana-"** ]]; then
            __version=${i#grafana-}
            if [ "$(grep GNU $i/LICENSE)" != "" ]; then
               gossv="$gossv $__version"
            else
               genterv="$genterv $__version"
            fi
         fi
      done
      GRAFANA_ENTERPRISE_VERSIONS=$(sortVersionList "$genterv")
      GRAFANA_OSS_VERSIONS=$(sortVersionList "$gossv")

      # Derby
      __versions=""
      for i in db-derby-*; do
         #__version=${i#db-derby-}
         __version=$i
         __versions="$__versions $__version "
      done
      __versions=$(echo $__versions | sed 's/-bin//g')
      DERBY_VERSIONS=$(sortVersionList "$__versions")

      # Mosquitto
      __versions=""
      for i in mosquitto-*; do
         __version=${i#mosquitto-}
         __versions="$__versions $__version "
      done
      MOSQUITTO_VERSIONS=$(sortVersionList "$__versions")

      popd > /dev/null 2>&1
            
   fi
}

# 
# Returns "true" if number, else "false"
# @param number
#
function isNumber
{
   num=$1
   [ ! -z "${num##*[!0-9]*}" ] && echo "true" || echo "false";
}

#
# Prompts user for the product version to install.
#
# @required PRODUCT_NAME              Product name
# @required PRODUCT_DOWNLOAD_VERSIONS Downloadable product versions
# @required INSTALLED_VERSIONS        Installed product versions
# @return INSTALL_VERSION             Returns the user-entered version to install. If this variable value is empty then the
#                                     user decided not to install.
#
function doUserInput
{
   INSTALL_VERSION=""

   local __INDEX=0
   local __LEN=${#PRODUCT_DOWNLOAD_VERSIONS[@]}
   let __LAST_INDEX=__LEN-1
   for i in ${PRODUCT_DOWNLOAD_VERSIONS[@]}; do
      __INSTALLED="false"
      for j in ${INSTALLED_VERSIONS[@]}; do
         if [[ "$j" == "${i#*_}" ]]; then
            __INSTALLED="true"
            break;
         elif [ "$i" == "confluent-community-$j" ]; then
            # community
            if [ ! -f "$PADOGRID_ENV_BASE_PATH/products/confluent-$j/bin/confluent-hub" ]; then
               __INSTALLED="true"
               break;
            fi
         elif [ "$i" == "confluent-$j" ]; then
            # commercial
            if [ -f "$PADOGRID_ENV_BASE_PATH/products/confluent-$j/bin/confluent-hub" ]; then
               __INSTALLED="true"
               break;
            fi
         fi
      done
      if [ "$__INSTALLED" == "true" ]; then
         echo "   [$__INDEX] $i [installed]"
      else
         echo "   [$__INDEX] $i"
      fi
      let __INDEX=__INDEX+1
   done

   local __INNER_LOOP=true
   local __INSTALLED="false"
   while [ "$__INNER_LOOP" == "true" ]; do
      read -p "Enter a version to install or leave blank to skip: " INPUT
      if [ "$INPUT" == "" ]; then
         break;
      else
         if [ "$(isNumber $INPUT)" == "true" ]; then
            if [ $INPUT -lt 0 ] || [ $INPUT -gt $__LAST_INDEX ]; then
               echo "Invalid number. Enter [0, $__LAST_INDEX]."
               continue;
            fi
         fi
         __INSTALLED="false"
         if [ "$(isNumber $INPUT)" == "true" ]; then
            INSTALL_VERSION=${PRODUCT_DOWNLOAD_VERSIONS[$INPUT]}
         else
            INSTALL_VERSION=$INPUT
         fi
         for j in ${INSTALLED_VERSIONS[@]}; do
           # if [ "$INSTALL_VERSION" == "$j" ]; then
            if [[ "$j" == "${INSTALL_VERSION#*_}" ]]; then
               __INSTALLED="true"
               break;
            fi
         done
         if [ "$__INSTALLED" == "true" ]; then
            local __REDO="true"
            while [ "$__REDO" == "true" ]; do
               read -p "$INSTALL_VERSION is already installed. Do you want to reinstall (y/[n])? " INPUT
               case $INPUT in
                  [Yy]* ) __REDO="false"; __INNER_LOOP="false";;
                  [Nn]* ) __REDO="false"; INSTALL_VERSION="";;
               esac
            done
         else
            if [ "$INSTALL_VERSION" != "" ]; then
               local __VALID_VERSION="false"
               for i in ${PRODUCT_DOWNLOAD_VERSIONS[@]}; do
                  if [ "$i" == $INSTALL_VERSION ]; then
                     __VALID_VERSION="true"
                     break;
                  fi
               done

               if [ "$__VALID_VERSION" == "false" ]; then
                  echo "$INSTALL_VERSION is invalid."
                  __INNER_LOOP="true"
               else
                  __INNER_LOOP="false"
               fi
            fi
         fi
      fi
   done
   if [ "$INSTALL_VERSION" == "" ]; then
      echo -e "$PRODUCT_NAME Selected: ${CBrownOrange}Skipped${CNone}"
   else
      echo -e "$PRODUCT_NAME Selected: ${CGo}$INSTALL_VERSION${CNone}"
   fi
}

#
# Installs the specified product in the PadoGrid products directory.
# @param productName Product name, i.e., padogrid, pado, geode, hazelcast-oss, hazelcast-enterprise, hazelcast-management-center, 
#                    hazelcast-desktop, snappydata, spark
# @param simulate If 'true' then outputs the installation commands without actually executing them.
#
# @required PADOGRID_PRODUCTS_PATH
# @required PADOGRID_DOWNLOADS_PATH
#
# @required PADOGRID_DOWNLOAD_URL
# @required PADOGRID_RELEASE
# @required PADOGRID_TARBALL
#
# @required PADO_DOWNLOAD_URL
# @required PADO_RELEASE
# @required PADO_TARBALL
#
# @required PADODESKTOP_DOWNLOAD_URL
# @required PADODESKTOP_RELEASE
# @required PADODESKTOP_TARBALL
#
# @required PADOWEB_DOWNLOAD_URL
# @required PADOWEB_RELEASE
# @required PADOWEB_TARBALL
#
# @required PADOECLIPSE_DOWNLOAD_URL
# @required PADOECLIPSE_RELEASE
# @required PADOECLIPSE_TARBALL
#
# @required GEODE_VERSION
# @required GEODE_TARBALL
#
# @required HAZELCAST_OSS_RELEASE
# @required HAZELCAST_OSS_TARBALL
#
# @required HAZELCAST_ENTERPRISE_RELEASE
# @required HAZELCAST_ENTERPRISE_TARBALL
#
# @required HAZELCAST_MC_RELEASE
# @required HAZELCAST_MC_TARBALL
#
# @required HAZELCAST_DESKTOP_VERSION
# @required HAZELCAST_DESKTOP_RELEASE
# @required HAZELCAST_DESKTOP_TARBALL
#
# @required REDIS_RELEASE
# @required REDIS_TARBALL
#
# @required SNAPPYDATA_RELEASE
# @required SNAPPYDATA_TARBALL
#
# @required SPARK_RELEASE
# @required SPARK_TARBALL
# @required SPARK_DIST_VERSION
#
# @required KAFKA_RELEASE
# @required KAFKA_TARBALL
#
# @required CONFLUENT_MINOR_VERSION
# @required CONFLUENT_TARBALL
#
# @required HADOOP_RELEASE
# @required HADOOP_TARBALL
#
# @required PROMETHEUS_VERSION
# @required PROMETHEUS_RELEASE
# @required PROMETHEUS_TARBALL
#
# @required GRAFANA_ENTERPRISE_RELEASE
# @required GRAFANA_ENTERPRISE_TARBALL
#
# @required GRAFANA_OSS_RELEASE
# @required GRAFANA_OSS_TARBALL
#
# @required DERBY_VERSION
# @required DERBY_TARBALL
#
# @required MOSQUITTO_RELEASE
# @required MOSQUITTO_TARBALL
#
function installProduct
{
   local __PRODUCT="$1"
   local __SIMULATE="$2"

   if [ "$__PRODUCT" == "padogrid" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$PADOGRID_RELEASE" ]; then
         echo "Already installed - $PADOGRID_RELEASE"
      else
         # --------------
         # Download PadoGrid
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$PADOGRID_TARBALL..."
         if [[ "$PADOGRID_RELEASE" == *"SNAPSHOT" ]]; then
            local VDIR="snapshot"
         else
            local VDIR="$PADOGRID_RELEASE"
         fi
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$PADOGRID_TARBALL" "https://github.com/padogrid/padogrid/releases/download/$VDIR/$PADOGRID_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$PADOGRID_TARBALL" "https://github.com/padogrid/padogrid/releases/download/$VDIR/$PADOGRID_TARBALL"
         fi
      
         # Install PadoGrid
         echo "  Installing PadoGrid $PADOGRID_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$PADOGRID_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$PADOGRID_TARBALL"
            echo "  Installed - $PADOGRID_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "pado" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$PADO_RELEASE" ]; then
         echo "Already installed - $PADO_RELEASE"
      else
         # --------------
         # Download Pado
         local FILE_NAME=${PADO_TARBALL#*/}
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$FILE_NAME..."
         if [ "$__SIMULATE" == "true" ]; then
            #echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$PADO_TARBALL" "https://github.com/netcrest/pado2/releases/download/$PADO_RELEASE/$PADO_TARBALL"
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADO_TARBALL"
         else
            #curl -sL -o "$PADO_DOWNLOADS_PATH/$PADO_TARBALL" "https://github.com/netcrest/pado2/releases/download/$PADO_RELEASE/$PADO_TARBALL"
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADO_TARBALL"
         fi
      
         # Install Pado
         #echo "  Installing Pado $PADO_TARBALL in $PADO_PRODUCTS_PATH/..."
         echo "  Installing Pado $FILE_NAME in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            #echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$PADO_TARBALL"
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME"
         else
            #tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$PADO_TARBALL"
            #echo "  Installed - $PADO_TARBALL"
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME"
            echo "  Installed - $FILE_NAME"
         fi
      fi

   elif [ "$__PRODUCT" == "padodesktop" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$PADODESKTOP_RELEASE" ]; then
         echo "Already installed - $PADODESKTOP_RELEASE"
      else
         # --------------
         # Download PadoDesktop
         local FILE_NAME=${PADODESKTOP_TARBALL#*/}
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$FILE_NAME..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADODESKTOP_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADODESKTOP_TARBALL"
         fi
      
         # Install PadoDesktop
         echo "  Installing PadoDesktop $FILE_NAME in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME"
            echo "  Installed - $FILE_NAME"
         fi
      fi

   elif [ "$__PRODUCT" == "padoweb" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$PADOWEB_RELEASE" ]; then
         echo "Already installed - $PADOWEB_RELEASE"
      else
         # --------------
         # Download PadoWeb
         local FILE_NAME=${PADOWEB_TARBALL#*/}
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$FILE_NAME..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADOWEB_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADOWEB_TARBALL"
         fi
      
         # Install PadoWeb
         echo "  Installing PadoWeb $FILE_NAME in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME"
            echo "  Installed - $FILE_NAME"
         fi
      fi

   elif [ "$__PRODUCT" == "padoeclipse" ]; then 

      # --------------
      # Download PadoEclipse (Download only. Manual installation required)
      local FILE_NAME=${PADOECLIPSE_JAR#*/}
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$FILE_NAME..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADOECLIPSE_JAR"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$FILE_NAME" "https://github.com/padogrid/padogrid/releases/download/$PADOECLIPSE_JAR"
         echo "  Downloaded - $FILE_NAME"
         echo -e "  ${CBrownOrange}To install the downloaded PadoEclipse plugin, place it in the Eclipse's 'dropins' folder.${CNone}"
         echo -e "  ${CBrownOrange}See the following link for instructions.${CNone}"
         echo -e "     ${CUrl}$PADOECLIPSE_MANUAL_URL${CNone}"
      fi
      
   elif [ "$__PRODUCT" == "geode" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$GEODE_RELEASE" ]; then
         echo "Already installed - $GEODE_RELEASE"
      else
      # --------------
      # Download Geode
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$GEODE_TARBALL..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$GEODE_TARBALL" "https://archive.apache.org/dist/geode/$GEODE_VERSION/$GEODE_TARBALL"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$GEODE_TARBALL" "https://archive.apache.org/dist/geode/$GEODE_VERSION/$GEODE_TARBALL"
      fi
      
      # Install Geode
      echo "  Installing Apache Geode $GEODE_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$GEODE_TARBALL"
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$GEODE_TARBALL"
         echo "  Installed - $GEODE_TARBALL"
      fi
      fi
      
   elif [ "$__PRODUCT" == "hazelcast-oss" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$HAZELCAST_OSS_RELEASE" ]; then
         echo "Already installed - $HAZELCAST_OSS_RELEASE"
      else
      # --------------
      # Download Hazelcast OSS
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_OSS_TARBALL..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_OSS_TARBALL" "https://download.hazelcast.com/download.jsp?version=$HAZELCAST_OSS_RELEASE&type=tar&p="
      else
         HEADER_VERSION="${HAZELCAST_OSS_VERSION%-slim}"
         if [[ "$HAZELCAST_OSS_RELEASE" == *"slim" ]]; then
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_OSS_TARBALL" "https://github.com/hazelcast/hazelcast/releases/download/v$HEADER_VERSION/$HAZELCAST_OSS_TARBALL"
         else
             curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_OSS_TARBALL" "https://github.com/hazelcast/hazelcast/releases/download/v$HEADER_VERSION/$HAZELCAST_OSS_TARBALL"
         fi
      fi
      
      # Install Hazelcast OSS
      echo "  Installing Hazelcast OSS $HAZELCAST_OSS_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_OSS_TARBALL
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_OSS_TARBALL
         echo "  Installed - $HAZELCAST_OSS_TARBALL"
      fi
      fi
      
   elif [ "$__PRODUCT" == "hazelcast-enterprise" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$HAZELCAST_ENTERPRISE_RELEASE" ]; then
         echo "Already installed - $HAZELCAST_ENTERPRISE_RELEASE"
      else
      # --------------
      # Download Hazelcast Enterprise
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_ENTERPRISE_TARBALL..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_ENTERPRISE_TARBALL" "https://repository.hazelcast.com/download/hazelcast-enterprise/$HAZELCAST_ENTERPRISE_TARBALL"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_ENTERPRISE_TARBALL" "https://repository.hazelcast.com/download/hazelcast-enterprise/$HAZELCAST_ENTERPRISE_TARBALL"
      fi
      
      # Install Hazelcast Enterprise
      echo "  Installing Hazelcast Enterprise $HAZELCAST_ENTERPRISE_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_ENTERPRISE_TARBALL"
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_ENTERPRISE_TARBALL"
         echo "  Installed - $HAZELCAST_ENTERPRISE_TARBALL"
      fi
      fi

   elif [ "$__PRODUCT" == "hazelcast-management-center" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$HAZELCAST_MC_RELEASE" ]; then
         echo "Already installed - $HAZELCAST_MC_RELEASE"
      else
      # --------------
      # Download Hazelcast Management Center
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_MC_TARBALL..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_MC_TARBALL" "https://repository.hazelcast.com/download/management-center/$HAZELCAST_MC_TARBALL"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_MC_TARBALL" "https://repository.hazelcast.com/download/management-center/$HAZELCAST_MC_TARBALL"
      fi
      
      # Install Hazelcast Management Center
      echo "  Installing Hazelcast Management Center $HAZELCAST_MC_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_MC_TARBALL
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_MC_TARBALL
         echo "  Installed - $HAZELCAST_MC_TARBALL"
      fi
      fi

   elif [ "$__PRODUCT" == "hazelcast-desktop" ]; then 

      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$HAZELCAST_DESKTOP_RELEASE" ]; then
         echo "Already installed - $HAZELCAST_DESKTOP_RELEASE"
      else
      # --------------
      # Download HazelcastDesktop
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_DESKTOP_TARBALL..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_DESKTOP_TARBALL" "https://github.com/netcrest/hazelcast-desktop/releases/download/$HAZELCAST_DESKTOP_VERSION/$HAZELCAST_DESKTOP_TARBALL"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HAZELCAST_DESKTOP_TARBALL" "https://github.com/netcrest/hazelcast-desktop/releases/download/$HAZELCAST_DESKTOP_VERSION/$HAZELCAST_DESKTOP_TARBALL"
      fi
      
      # Install HazelcastDesktop
      echo "  Installing HazelcastDesktop $HAZELCAST_DESKTOP_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_DESKTOP_TARBALL
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf $PADOGRID_DOWNLOADS_PATH/$HAZELCAST_DESKTOP_TARBALL
         echo "  Installed - $HAZELCAST_DESKTOP_TARBALL"
      fi
      fi

   elif [ "$__PRODUCT" == "redis-oss" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$REDIS_RELEASE" ]; then
         echo "Already installed - $REDIS_RELEASE"
      else
      # --------------
      # Download Redis
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$REDIS_TARBALL..."
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$REDIS_TARBALL" "https://github.com/redis/redis/archive/refs/tags/$REDIS_VERSION.tar.gz"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$REDIS_TARBALL" "https://github.com/redis/redis/archive/refs/tags/$REDIS_VERSION.tar.gz"
      fi
      
      # Install Redis
      echo "  Installing Redis $REDIS_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$REDIS_TARBALL"
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$REDIS_TARBALL"
         echo "  Installed - $REDIS_TARBALL"
      fi
      fi

   elif [ "$__PRODUCT" == "snappydata" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$SNAPPYDATA_RELEASE" ]; then
         echo "Already installed - $SNAPPYDATA_RELEASE"
      else
      # --------------
      # Download SnappyData
      echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$SNAPPYDATA_TARBALL..."
      SNAPPY_VDIR="v${SNAPPYDATA_VERSION%-bin}"
      # Remove hot release part
      SNAPPY_VDIR="$(echo $SNAPPY_VDIR | sed 's/-.*$//')"
      if [ "$__SIMULATE" == "true" ]; then
         echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$SNAPPYDATA_TARBALL" "https://github.com/TIBCOSoftware/snappydata/releases/download/$SNAPPY_VDIR/$SNAPPYDATA_TARBALL"
      else
         curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$SNAPPYDATA_TARBALL" "https://github.com/TIBCOSoftware/snappydata/releases/download/$SNAPPY_VDIR/$SNAPPYDATA_TARBALL"
      fi
      
      # Install SnappyData
      echo "  Installing SnappyData $SNAPPYDATA_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
      if [ "$__SIMULATE" == "true" ]; then
         echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$SNAPPYDATA_TARBALL"
      else
         tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$SNAPPYDATA_TARBALL"
         echo "  Installed - $SNAPPYDATA_TARBALL"
      fi
      fi

   elif [ "$__PRODUCT" == "spark" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$SPARK_DIST_VERSION" ]; then
         echo "Already installed - $SPARK_DIST_VERSION"
      else
         # --------------
         # Download Spark
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$SPARK_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$SPARK_TARBALL" "https://archive.apache.org/dist/spark/$SPARK_RELEASE/$SPARK_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$SPARK_TARBALL" "https://archive.apache.org/dist/spark/$SPARK_RELEASE/$SPARK_TARBALL"
         fi
      
         # Install Spark
         echo "  Installing Spark $SPARK_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$SPARK_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$SPARK_TARBALL"
            echo "  Installed - $SPARK_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "kafka" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$KAFKA_DIST_VERSION" ]; then
         echo "Already installed - $KAFKA_DIST_VERSION"
      else
         # --------------
         # Download Kafka
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$KAFKA_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$KAFKA_TARBALL" "https://archive.apache.org/dist/kafka/$KAFKA_RELEASE/$KAFKA_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$KAFKA_TARBALL" "https://archive.apache.org/dist/kafka/$KAFKA_RELEASE/$KAFKA_TARBALL"
         fi
      
         # Install Kafka
         echo "  Installing Kafka $KAFKA_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$KAFKA_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$KAFKA_TARBALL"
            echo "  Installed - $KAFKA_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "confluent" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$CONFLUENT_DIST_VERSION" ]; then
         echo "Already installed - $CONFLUENT_DIST_VERSION"
      else
         # --------------
         # Download Kafka
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$CONFLUENT_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$CONFLUENT_TARBALL" "https://packages.confluent.io/archive/$CONFLUENT_MINOR_VERSION/$CONFLUENT_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$CONFLUENT_TARBALL" "https://packages.confluent.io/archive/$CONFLUENT_MINOR_VERSION/$CONFLUENT_TARBALL"
         fi
      
         # Install Kafka
         echo "  Installing Confluent $CONFLUENT_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$CONFLUENT_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$CONFLUENT_TARBALL"
            echo "  Installed - $CONFLUENT_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "hadoop" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$HADOOP_VERSION" ]; then
         echo "Already installed - $HADOOP_VERSION"
      else
         # --------------
         # Download Hadoop
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$HADOOP_TARBALL..."
         echo "  Hadoop is known to take a long time to download."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HADOOP_TARBALL" "https://archive.apache.org/dist/hadoop/common/$HADOOP_RELEASE/$HADOOP_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$HADOOP_TARBALL" "https://archive.apache.org/dist/hadoop/common/$HADOOP_RELEASE/$HADOOP_TARBALL"
         fi
      
         # Install Hadoop
         echo "  Installing Hadoop $HADOOP_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$HADOOP_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$HADOOP_TARBALL"
            echo "  Installed - $HADOOP_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "prometheus" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$PROMETHEUS_RELEASE" ]; then
         echo "Already installed - $PROMETHEUS_RELEASE"
      else
         # --------------
         # Download Prometheus
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$PROMETHEUS_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$PROMETHEUS_TARBALL" "https://github.com/prometheus/prometheus/releases/download/v$PROMETHEUS_VERSION/$PROMETHEUS_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$PROMETHEUS_TARBALL" "https://github.com/prometheus/prometheus/releases/download/v$PROMETHEUS_VERSION/$PROMETHEUS_TARBALL"
         fi
         
         # Install Prometheus
         echo "  Installing Prometheus $PROMETHEUS_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$PROMETHEUS_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$PROMETHEUS_TARBALL"
            echo "  Installed - $PROMETHEUS_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "grafana-enterprise" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/grafana-$GRAFANA_ENTERPRISE_VERSION" ]; then
         echo "Already installed - $GRAFANA_ENTERPRISE_VERSION"
      else
         # --------------
         # Download Grafana
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$GRAFANA_ENTERPRISE_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_ENTERPRISE_TARBALL" "https://dl.grafana.com/enterprise/release/$GRAFANA_ENTERPRISE_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_ENTERPRISE_TARBALL" "https://dl.grafana.com/enterprise/release/$GRAFANA_ENTERPRISE_TARBALL"
         fi
         
         # Install Grafana
         echo "  Installing Grafana Eterprise $GRAFANA_ENTERPRISE_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_ENTERPRISE_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_ENTERPRISE_TARBALL"
            echo "  Installed - $GRAFANA_ENTERPRISE_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "grafana-oss" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/grafana-$GRAFANA_OSS_VERSION" ]; then
         echo "Already installed - $GRAFANA_OSS_VERSION"
      else
         # --------------
         # Download Grafana
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$GRAFANA_OSS_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_OSS_TARBALL" "https://dl.grafana.com/oss/release/$GRAFANA_OSS_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_OSS_TARBALL" "https://dl.grafana.com/oss/release/$GRAFANA_OSS_TARBALL"
         fi
         
         # Install Grafana
         echo "  Installing Grafana OSS $GRAFANA_OSS_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_OSS_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$GRAFANA_OSS_TARBALL"
            echo "  Installed - $GRAFANA_OSS_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "derby" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$DERBY_RELEASE" ]; then
         echo "Already installed - $DERBY_RELEASE"
      else
         # --------------
         # Download Derby
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$DERBY_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$DERBY_TARBALL" "https://archive.apache.org/dist/db/derby/$DERBY_VERSION/$DERBY_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$DERBY_TARBALL" "https://archive.apache.org/dist/db/derby/$DERBY_VERSION/$DERBY_TARBALL"
         fi
         
         # Install Derby
         echo "  Installing Apache Derby $DERBY_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$DERBY_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$DERBY_TARBALL"
            echo "  Installed - $DERBY_TARBALL"
         fi
      fi

   elif [ "$__PRODUCT" == "mosquitto" ]; then 
      
      if [ "$QUIET" == "true" ] &&  [ -d "$PADOGRID_PRODUCTS_PATH/$MOSQUITTO_RELEASE" ]; then
         echo "Already installed - $MOSQUITTO_RELEASE"
      else
         # --------------
         # Download Mosquitto
         echo "+ Downloading $PADOGRID_DOWNLOADS_PATH/$MOSQUITTO_TARBALL..."
         if [ "$__SIMULATE" == "true" ]; then
            echo curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$MOSQUITTO_TARBALL" "$MOSQUITTO_DOWNLOAD_URL/$MOSQUITTO_TARBALL"
         else
            curl -sL -o "$PADOGRID_DOWNLOADS_PATH/$MOSQUITTO_TARBALL" "$MOSQUITTO_DOWNLOAD_URL/$MOSQUITTO_TARBALL"
         fi
      
         # Install Mosquitto
         echo "  Installing Mosquitto $MOSQUITTO_TARBALL in $PADOGRID_PRODUCTS_PATH/..."
         if [ "$__SIMULATE" == "true" ]; then
            echo tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$MOSQUITTO_TARBALL"
         else
            tar -C $PADOGRID_PRODUCTS_PATH -xzf "$PADOGRID_DOWNLOADS_PATH/$MOSQUITTO_TARBALL"
            echo "  Installed - $MOSQUITTO_TARBALL"
         fi
      fi

   fi

}

# Simulation message
if [ "$SIMULATE" == "true" ]; then
   echo ""
   if [ "$SAVE_SPECIFIED" == "true" ]; then
      echo "You have specified both '-save' and '-simulate'. Simulation ignored."
   else
      echo -e "${CBrownOrange}Simulation Only. You have specified the '-simulate' option. File downloads will be"
      echo -e "simulated and will not be downloaded.${CNone}"
   fi
fi

if [ "$FILE_SPECIFIED" == "true" ]; then
   if [ "$FILE_ARG" == "" ]; then
      echo -e "${CError}ERROR:${CNone} '-file' option required file path. Command aborted."
      exit 1
   fi
   if [ ! -f "$FILE_ARG" ]; then
      echo -e "${CError}ERROR:${CNone} File not found: [$FILE_ARG]. Command aborted."
      exit 1
   fi
   FILE_NAME=$(basename "$FILE_ARG")
   if [[ "$FILE_NAME" != "padogrid_"* ]] || [[ "$FILE_NAME" != *".tar.gz" ]]; then
      echo -e "${CError}ERROR:${CNone} Invalid padogrid distribution file name. [$FILE_ARG]. Command aborted."
      exit 1
   fi
   PADOGRID_VERSION=$(tar tzvf $FILE_ARG  |grep padogrid_ | grep padogrid-common- | sed 's/.*padogrid-common-//')
   PADOGRID_VERSION=${PADOGRID_VERSION%.jar}
   if [ "$PADOGRID_VERSION" == "" ]; then
      echo -e "${CError}ERROR:${CNone} Invalid contents in distribution. [$FILE_ARG]. Command aborted."
      exit 1
   fi
fi

if [ "$SAVE_SPECIFIED" == "true" ] && [ "$DOWNLOAD_VERSIONS_FILE" != "" ]; then
   __DIR=$(dirname $DOWNLOAD_VERSIONS_FILE)
   if [ ! -d "$__DIR" ]; then
      echo -e "${CError}ERROR:${CNone} Invalid file path. Directory does not exist. Command aborted."
      echo "   $DOWNLOAD_VERSIONS_FILE"
      exit 1
   fi
   if [ ! -w "$__DIR" ]; then
      echo -e "${CError}ERROR:${CNone} Invalid file path. You do not have write permissions. Command aborted."
      echo "   $DOWNLOAD_VERSIONS_FILE"
      exit 1
   fi
   echo ""
   echo "Product versions will be saved in the specified file."
   echo "   $DOWNLOAD_VERSIONS_FILE"
fi

if [ "$FILE_SPECIFIED" != "true" ] && [ "$SCAN_SPECIFIED" != "true" ] && [ "$DOWNLOAD_VERSIONS_FILE" == "" ]; then
   # Download the cached product versions
   if [ ! -d "$PADOGRID_DOWNLOADS_PATH" ]; then
      DOWNLOAD_VERSIONS_FILE="/tmp/padogrid_download_versions-$(date "+%m%d%y%H%M%S").sh"
   else
      DOWNLOAD_VERSIONS_FILE="$PADOGRID_DOWNLOADS_PATH/padogrid_download_versions.sh"
   fi
   curl -sL -o "$DOWNLOAD_VERSIONS_FILE" "$DOWNLOAD_VERSIONS_URL"
fi
if [ "$FILE_SPECIFIED" != "true" ] && [ "$SCAN_SPECIFIED" != "true" ] && [ -f "$DOWNLOAD_VERSIONS_FILE" ]; then
   . "$DOWNLOAD_VERSIONS_FILE"
   rm "$DOWNLOAD_VERSIONS_FILE"
   PADOGRID_DOWNLOAD_VERSIONS=($PADOGRID_DOWNLOAD_VERSIONS)
   PADO_DOWNLOAD_VERSIONS=($PADO_DOWNLOAD_VERSIONS)
   PADODESKTOP_DOWNLOAD_VERSIONS=($PADODESKTOP_DOWNLOAD_VERSIONS)
   PADOWEB_DOWNLOAD_VERSIONS=($PADOWEB_DOWNLOAD_VERSIONS)
   PADOECLIPSE_DOWNLOAD_VERSIONS=($PADOECLIPSE_DOWNLOAD_VERSIONS)
   GEODE_DOWNLOAD_VERSIONS=($GEODE_DOWNLOAD_VERSIONS)
   HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS=($HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS)
   HAZELCAST_OSS_DOWNLOAD_VERSIONS=($HAZELCAST_OSS_DOWNLOAD_VERSIONS)
   HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS=($HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS)
   HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS=($HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS)
   REDIS_DOWNLOAD_VERSIONS=($REDIS_DOWNLOAD_VERSIONS)
   SNAPPYDATA_DOWNLOAD_VERSIONS=($SNAPPYDATA_DOWNLOAD_VERSIONS)
   SPARK_DOWNLOAD_VERSIONS=($SPARK_DOWNLOAD_VERSIONS)
   KAFKA_DOWNLOAD_VERSIONS=($KAFKA_DOWNLOAD_VERSIONS)
   CONFLUENT_DOWNLOAD_VERSIONS=$(sortVersionList "$CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS $CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS")
   CONFLUENT_DOWNLOAD_VERSIONS=($CONFLUENT_DOWNLOAD_VERSIONS)
   HADOOP_DOWNLOAD_VERSIONS=($HADOOP_DOWNLOAD_VERSIONS)
   PROMETHEUS_DOWNLOAD_VERSIONS=($PROMETHEUS_DOWNLOAD_VERSIONS)
   GRAFANA_DOWNLOAD_VERSIONS=($GRAFANA_DOWNLOAD_VERSIONS)
   DERBY_DOWNLOAD_VERSIONS=($DERBY_DOWNLOAD_VERSIONS)
   MOSQUITTO_DOWNLOAD_VERSIONS=($MOSQUITTO_DOWNLOAD_VERSIONS)
elif [ "$FILE_SPECIFIED" != "true" ]; then
   #
   # Scan downloadable product versions
   #
   echo ""
   echo "Scanning downloadable products... Please wait."
   echo ""

   # Turn off the enter key while waiting
   if [ "$NO_STTY_SPECIFIED" != "true" ]; then
      stty igncr
   fi

   PADOGRID_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadablePadogridVersions)"))
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "pado" ]; then
      PADO_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadablePadoVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padodesktop" ]; then
      PADODESKTOP_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadablePadodesktopVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padoweb" ]; then
      PADOWEB_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadablePadowebVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padoeclipse" ]; then
      PADOECLIPSE_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadablePadoEclipseVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "geode" ]; then
      GEODE_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableGeodeVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-enterprise" ]; then
      HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableHazelcastEnterpriseVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-oss" ]; then
      HAZELCAST_OSS_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableHazelcastOssVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-mc" ]; then
      HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableHazelcastManCenterVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-desktop" ]; then
      HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableHazelcastDesktopVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "redis-oss" ]; then
      REDIS_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableRedisVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "snappydata" ]; then
      SNAPPYDATA_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableSnappyDataVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "spark" ]; then
      SPARK_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableSparkVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "kafka" ]; then
      KAFKA_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableKafkaVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "confluent" ]; then
      CONFLUENT_DOWNLOAD_VERSIONS=$(getDownloadableConfluentVersions)
      CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS=""
      CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS=""
      for i in $CONFLUENT_DOWNLOAD_VERSIONS; do
         if [[ "$i" == *"confluent-community"* ]]; then
            CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS="$CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS $i"
         else
            CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS="$CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS $i"
         fi
      done
      CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS=($(sortVersionList "$CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS"))
      CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS=($(sortVersionList "$CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS"))
      CONFLUENT_DOWNLOAD_VERSIONS=($(sortVersionList "$CONFLUENT_DOWNLOAD_VERSIONS"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hadoop" ]; then
      HADOOP_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableHadoopVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "prometheus" ]; then
      PROMETHEUS_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadablePrometheusVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "grafana-enterprise" ] || [ "$PRODUCT_ARG" == "grafana-oss" ]; then
      GRAFANA_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableGrafanaVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "derby" ]; then
      DERBY_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableDerbyVersions)"))
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "mosquitto" ]; then
      MOSQUITTO_DOWNLOAD_VERSIONS=($(sortVersionList "$(getDownloadableMosquittoVersions)"))
   fi

   # Enable the enter key
   if [ "$NO_STTY_SPECIFIED" != "true" ]; then
      stty -igncr
   fi
fi

# Save downloadable versions and exit
if [ "$FILE_SPECIFIED" != "true" ] && [ "$SAVE_SPECIFIED" == "true" ]; then
   echo "PADOGRID_DOWNLOAD_VERSIONS=\"${PADOGRID_DOWNLOAD_VERSIONS[@]}\"" > "$DOWNLOAD_VERSIONS_FILE"
   echo "PADO_DOWNLOAD_VERSIONS=\"${PADO_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "PADODESKTOP_DOWNLOAD_VERSIONS=\"${PADODESKTOP_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "PADOWEB_DOWNLOAD_VERSIONS=\"${PADOWEB_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "PADOECLIPSE_DOWNLOAD_VERSIONS=\"${PADOECLIPSE_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "GEODE_DOWNLOAD_VERSIONS=\"${GEODE_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS=\"${HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "HAZELCAST_OSS_DOWNLOAD_VERSIONS=\"${HAZELCAST_OSS_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS=\"${HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS=\"${HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "REDIS_DOWNLOAD_VERSIONS=\"${REDIS_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "SNAPPYDATA_DOWNLOAD_VERSIONS=\"${SNAPPYDATA_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "SPARK_DOWNLOAD_VERSIONS=\"${SPARK_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "KAFKA_DOWNLOAD_VERSIONS=\"${KAFKA_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS=\"${CONFLUENT_COMMERCIAL_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS=\"${CONFLUENT_COMMUNITY_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "HADOOP_DOWNLOAD_VERSIONS=\"${HADOOP_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "PROMETHEUS_DOWNLOAD_VERSIONS=\"${PROMETHEUS_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "GRAFANA_DOWNLOAD_VERSIONS=\"${GRAFANA_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "DERBY_DOWNLOAD_VERSIONS=\"${DERBY_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "MOSQUITTO_DOWNLOAD_VERSIONS=\"${MOSQUITTO_DOWNLOAD_VERSIONS[@]}\"" >> "$DOWNLOAD_VERSIONS_FILE"
   echo "Downloadable product versions saved:"
   echo "   + $DOWNLOAD_VERSIONS_FILE"
   exit
fi

# Version variables set by user inputs
PADOGRID_VERSION=""
PADO_VERSION=""
PADODESKTOP_VERSION=""
PADOWEB_VERSION=""
PADOECLIPSE_VERSION=""
GEODE_VERSION=""
HAZELCAST_ENTERPRISE_VERSION=""
HAZELCAST_OSS_VERSION=""
HAZELCAST_MANAGEMENT_CENTER_VERSION=""
HAZELCAST_DESKTOP_VERSION=""
REDIS_VERSION=""
SNAPPYDATA_VERSION=""
SPARK_VERSION=""
KAFKA_VERSION=""
CONFLUENT_VERSION=""
HADOOP_VERSION=""
PROMETHEUS_VERSION=""
GRAFANA_ENTERPRISE_VERSION=""
GRAFANA_OSS_VERSION=""
DERBY_VERSION=""
MOSQUITTO_VERSION=""

if [ "$FILE_SPECIFIED" != "true" ] && [ "$VERSION_SPECIFIED" == "true" ]; then

   INSTALL_COUNT=1
   case $PRODUCT_ARG in
      confluent )
         DOWNLOAD_VERSIONS=( "${CONFLUENT_DOWNLOAD_VERSIONS[@]}" )
         CONFLUENT_DIST_VERSION=$VERSION_ARG
         CONFLUENT_VERSION=$(echo $CONFLUENT_DIST_VERSION | sed 's/.*-//') ;;
      derby )
         DOWNLOAD_VERSIONS=( "${DERBY_DOWNLOAD_VERSIONS[@]}" )
         DERBY_VERSION=$VERSION_ARG ;;
      hadoop )
         DOWNLOAD_VERSIONS=( "${HADOOP_DOWNLOAD_VERSIONS[@]}" )
         HADOOP_VERSION=$VERSION_ARG ;;
      hazelcast-desktop )
         DOWNLOAD_VERSIONS=( "${HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS[@]}" )
         HAZELCAST_DESKTOP_VERSION=$VERSION_ARG ;;
      hazelcast-enterprise ) 
         DOWNLOAD_VERSIONS=( "${HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS[@]}" )
         HAZELCAST_ENTERPRISE_VERSION=$VERSION_ARG ;;
      hazelcast-mc )
         DOWNLOAD_VERSIONS=( "${HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS[@]}" )
         HAZELCAST_MANAGEMENT_CENTER_VERSION=$VERSION_ARG ;;
      hazelcast-oss )
         DOWNLOAD_VERSIONS=( "${HAZELCAST_OSS_DOWNLOAD_VERSIONS[@]}" )
         HAZELCAST_OSS_VERSION=$VERSION_ARG ;;
      geode )
         DOWNLOAD_VERSIONS=( "${GEODE_DOWNLOAD_VERSIONS[@]}" )
         GEODE_VERSION=$VERSION_ARG ;;
      grafana-enterprise )
         DOWNLOAD_VERSIONS=( "${GRAFANA_DOWNLOAD_VERSIONS[@]}" )
         GRAFANA_ENTERPRISE_VERSION=$VERSION_ARG ;;
      grafana-oss )
         DOWNLOAD_VERSIONS=( "${GRAFANA_DOWNLOAD_VERSIONS[@]}" )
         GRAFANA_OSS_VERSION=$VERSION_ARG ;;
      kafka )
         DOWNLOAD_VERSIONS=( "${KAFKA_DOWNLOAD_VERSIONS[@]}" )
         KAFKA_VERSION=$VERSION_ARG
         KAFKA_SCALA_VERSIONS_ARRAY=($(getScalaKafkaVersions "$KAFKA_VERSION"))
         # Pick the last one (newer version of scala)
         KAFKA_DIST_VERSION=${KAFKA_SCALA_VERSIONS_ARRAY[${#KAFKA_SCALA_VERSIONS_ARRAY[@]}-1]}
         ;;
      mosquitto )
         DOWNLOAD_VERSIONS=( "${MOSQUITTO_DOWNLOAD_VERSIONS[@]}" )
         MOSQUITTO_VERSION=$VERSION_ARG ;;
      pado )
         DOWNLOAD_VERSIONS=( "${PADO_DOWNLOAD_VERSIONS[@]}" )
         PADO_VERSION=$VERSION_ARG ;;
      padodesktop )
         DOWNLOAD_VERSIONS=( "${PADODESKTOP_DOWNLOAD_VERSIONS[@]}" )
         PADODESKTOP_VERSION=$VERSION_ARG ;;
      padoeclipse )
         DOWNLOAD_VERSIONS=( "${PADOECLIPSE_DOWNLOAD_VERSIONS[@]}" )
         PADOECLIPSE_VERSION=$VERSION_ARG ;;
      padogrid )
         DOWNLOAD_VERSIONS=( "${PADOGRID_DOWNLOAD_VERSIONS[@]}" )
         PADOGRID_VERSION=$VERSION_ARG ;;
      padoweb )
         DOWNLOAD_VERSIONS=( "${PADOWEB_DOWNLOAD_VERSIONS[@]}" )
         PADOWEB_VERSION=$VERSION_ARG ;;
      prometheus )
         DOWNLOAD_VERSIONS=( "${PROMETHEUS_DOWNLOAD_VERSIONS[@]}" )
         PROMETHEUS_VERSION=$VERSION_ARG ;;
      redis-oss )
         DOWNLOAD_VERSIONS=( "${REDIS_DOWNLOAD_VERSIONS[@]}" )
         REDIS_VERSION=$VERSION_ARG ;;
      snappydata )
         DOWNLOAD_VERSIONS=( "${SNAPPYDATA_DOWNLOAD_VERSIONS[@]}" )
         SNAPPYDATA_VERSION=$VERSION_ARG ;;
      spark )
         DOWNLOAD_VERSIONS=( "${SPARK_DOWNLOAD_VERSIONS[@]}" )
         SPARK_VERSION=$VERSION_ARG
         SPARK_DIST_VERSION=${SPARK_VERSION}-bin-without-hadoop ;;
      *) ;;
   esac

   found="false"
   for i in ${DOWNLOAD_VERSIONS[@]}; do
      if [ "$i" == "$VERSION_ARG" ]; then
         found="true"
      fi
   done

   if [ "$found" == "false" ]; then
      echo ""
      echo "Downloadable product versions: [$PRODUCT_ARG]"
      index=0
      for i in ${DOWNLOAD_VERSIONS[@]}; do
         echo "[$index] $i"
         let index=index+1
      done
      echo ""
      echo -e >&2 "${CError}ERROR:${CNone} Product version not found [$VERSION_ARG]. Command aborted."
      exit 1
   fi

   # Set the latest stable padogrid version if padogrid is not specified
   if [ "$PADOGRID_VERSION" == "" ]; then
      PADOGRID_VERSION=${PADOGRID_DOWNLOAD_VERSIONS[0]}
      if [[ "$PADOGRID_VERSION" == *"SNAPSHOT" ]]; then
         PADOGRID_VERSION=${PADOGRID_DOWNLOAD_VERSIONS[1]} 
      fi
      if [ "$PRODUCT_ARG" != "" ] && [ "$PRODUCT_ARG" != "padogrid" ] && [ -d "$PADOGRID_PRODUCTS_PATH/padogrid_$PADOGRID_VERSION" ]; then
         PADOGRID_VERSION=""
      fi
   fi

elif [ "$FILE_SPECIFIED" != "true" ] && [ "$QUIET" == "true" ]; then
   # Set the latest version
   PADOGRID_VERSION=${PADOGRID_DOWNLOAD_VERSIONS[0]}
   if [[ "$PADOGRID_VERSION" == *"SNAPSHOT" ]]; then
      PADOGRID_VERSION=${PADOGRID_DOWNLOAD_VERSIONS[1]} 
   fi
   if [ "$PRODUCT_ARG" != "" ] && [ "$PRODUCT_ARG" != "padogrid" ] && [ -d "$PADOGRID_PRODUCTS_PATH/padogrid_$PADOGRID_VERSION" ]; then
      PADOGRID_VERSION=""
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "pado" ]; then
      PADO_VERSION=${PADO_DOWNLOAD_VERSIONS[0]}
      if [[ "$PADO_VERSION" == *"SNAPSHOT" ]]; then
         PADO_VERSION=${PADO_DOWNLOAD_VERSIONS[1]} 
      fi
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padodesktop" ]; then
      PADODESKTOP_VERSION=${PADODESKTOP_DOWNLOAD_VERSIONS[0]}
      if [[ "$PADODESKTOP_VERSION" == *"SNAPSHOT" ]]; then
         PADODESKTOP_VERSION=${PADODESKTOP_DOWNLOAD_VERSIONS[1]} 
      fi
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padoweb" ]; then
      PADOWEB_VERSION=${PADOWEB_DOWNLOAD_VERSIONS[0]}
      if [[ "$PADOWEB_VERSION" == *"SNAPSHOT" ]]; then
         PADOWEB_VERSION=${PADOWEB_DOWNLOAD_VERSIONS[1]} 
      fi
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padoeclipse" ]; then
      PADOECLIPSE_VERSION=${PADOECLIPSE_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "geode" ]; then
      GEODE_VERSION=${GEODE_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-enterprise" ]; then
      HAZELCAST_ENTERPRISE_VERSION=${HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-oss" ]; then
      HAZELCAST_OSS_VERSION=${HAZELCAST_OSS_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-mc" ]; then
      HAZELCAST_MANAGEMENT_CENTER_VERSION=${HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-desktop" ]; then
      HAZELCAST_DESKTOP_VERSION=${HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "redis-oss" ]; then
      REDIS_VERSION=${REDIS_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "snappydata" ]; then
      SNAPPYDATA_VERSION=${SNAPPYDATA_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "spark" ]; then
      SPARK_VERSION=${SPARK_DOWNLOAD_VERSIONS[0]}
      SPARK_DIST_VERSION=${SPARK_VERSION}
      if [ "$SPARK_VERSION" != "" ]; then
         SPARK_DIST_VERSION=${SPARK_VERSION}-bin-without-hadoop
      fi
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "kafka" ]; then
      KAFKA_VERSION=${KAFKA_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "confluent" ]; then
      CONFLUENT_DIST_VERSION=${CONFLUENT_DOWNLOAD_VERSIONS[0]}
      CONFLUENT_VERSION=$(echo $CONFLUENT_DIST_VERSION | sed 's/.*-//')
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hadoop" ]; then
      HADOOP_VERSION=${HADOOP_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "prometheus" ]; then
      PROMETHEUS_VERSION=${PROMETHEUS_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "grafana-enterprise" ]; then
      # Install the enterprise version for grafana. Enterprise and OSS have the same installation directory.
      GRAFANA_ENTERPRISE_VERSION=${GRAFANA_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "grafana-oss" ]; then
      GRAFANA_OSS_VERSION=${GRAFANA_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "derby" ]; then
      DERBY_VERSION=${DERBY_DOWNLOAD_VERSIONS[0]}
   fi
   if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "mosquitto" ]; then
      MOSQUITTO_VERSION=${MOSQUITTO_DOWNLOAD_VERSIONS[0]}
   fi

   echo "Installing the latest product(s) as follows:"
   echo ""
   echo "PadoGrid             $PADOGRID_VERSION"
   echo "Pado                 $PADO_VERSION"
   echo "PadoDesktop          $PADODESKTOP_VERSION"
   echo "PadoWeb              $PADOWEB_VERSION"
   echo "PadoEclipse          $PADOECLIPSE_VERSION"
   echo "Geode                $GEODE_VERSION"
   echo "Hazelcast Enterprise $HAZELCAST_ENTERPRISE_VERSION"
   echo "Hazelcast OSS        $HAZELCAST_OSS_VERSION"
   echo "Hazelcast Man Center $HAZELCAST_MANAGEMENT_CENTER_VERSION"
   echo "HazelcastDesktop     $HAZELCAST_DESKTOP_VERSION"
   echo "Redis OSS            $REDIS_VERSION"
   echo "SnappyData           $SNAPPYDATA_VERSION"
   echo "Spark                $SPARK_VERSION"
   echo "Kafka                $KAFKA_VERSION"
   echo "Kafka Confluent      $CONFLUENT_VERSION"
   echo "Hadoop               $HADOOP_VERSION"
   echo "Prometheus           $PROMETHEUS_VERSION"
   echo "Grafana Enterprise   $GRAFANA_ENTERPRISE_VERSION"
   echo "Grafana OSS          $GRAFANA_OSS_VERSION"
   echo "Derby                $DERBY_VERSION"
   echo "Mosquitto            $MOSQUITTO_VERSION"
   echo ""
elif [ "$FILE_SPECIFIED" != "true" ]; then
   # Get user inputs
   REDO="true"
   while [ "$REDO" == "true" ]; do

      INSTALL_COUNT=0

      REDO=true
      INNER_LOOP=true
      while [ "$INNER_LOOP" == "true" ]; do
         echo "Enter the PadoGrid environment base directory path. All of the products will be installed in this directory."
         echo "[$PADOGRID_ENV_BASE_PATH]":
         read -p "" INPUT
         if [ "$INPUT" == "" ]; then
            __BASE_PATH="$PADOGRID_ENV_BASE_PATH"
         else
            __BASE_PATH="$INPUT"
         fi
         if [ ! -d "$__BASE_PATH" ]; then
            if [ -f "$__BASE_PATH" ]; then
               echo "Invalid path. The specified path exists and is not a directory."
               continue;
            fi
            __parent=$(dirname "$__BASE_PATH")
            if [ ! -w "$__parent" ]; then
               echo "Invalid path. You do not have write permissions to create directory: [$__parent]"
               continue;
            fi
         fi
         INNER_LOOP=false
         PADOGRID_ENV_BASE_PATH="$__BASE_PATH"
      done

      echo ""
      echo -e "PadoGrid environment base directory: ${CGo}$PADOGRID_ENV_BASE_PATH${CNone}"
      echo ""

      # Get local installations
      determineInstalledProductVersions

      # PadoGrid
      PRODUCT_NAME="PadoGrid"
      PRODUCT_DOWNLOAD_VERSIONS=("${PADOGRID_DOWNLOAD_VERSIONS[@]}")
      INSTALLED_VERSIONS=$PADOGRID_VERSIONS
      echo -e "PadoGrid ${CUrl}$PADOGRID_DOWNLOAD_URL${CNone}"
      doUserInput
      if [ "$INSTALL_VERSION" != "" ]; then
         let INSTALL_COUNT=INSTALL_COUNT+1
      fi
      PADOGRID_VERSION=$INSTALL_VERSION
      echo ""

      # Pado
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "pado" ]; then
         PRODUCT_NAME="Pado"
         PRODUCT_DOWNLOAD_VERSIONS=("${PADO_DOWNLOAD_VERSIONS[@]}")
         if [ ${#PRODUCT_DOWNLOAD_VERSIONS[@]} -gt 0 ]; then
         INSTALLED_VERSIONS=$PADO_VERSIONS
         echo -e "Pado ${CUrl}$PADO_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         PADO_VERSION=$INSTALL_VERSION
         echo ""
         fi
      fi

      # PadoDesktop
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padodesktop" ]; then
         PRODUCT_NAME="PadoDesktop"
         PRODUCT_DOWNLOAD_VERSIONS=("${PADODESKTOP_DOWNLOAD_VERSIONS[@]}")
         if [ ${#PRODUCT_DOWNLOAD_VERSIONS[@]} -gt 0 ]; then
         INSTALLED_VERSIONS=$PADODESKTOP_VERSIONS
         echo -e "PadoDesktop ${CUrl}$PADODESKTOP_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         PADODESKTOP_VERSION=$INSTALL_VERSION
         echo ""
         fi
      fi

      # PadoWeb
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padoweb" ]; then
         PRODUCT_NAME="PadoWeb"
         PRODUCT_DOWNLOAD_VERSIONS=("${PADOWEB_DOWNLOAD_VERSIONS[@]}")
         if [ ${#PRODUCT_DOWNLOAD_VERSIONS[@]} -gt 0 ]; then
         INSTALLED_VERSIONS=$PADOWEB_VERSIONS
         echo -e "PadoWeb ${CUrl}$PADOWEB_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         PADOWEB_VERSION=$INSTALL_VERSION
         echo ""
         fi
      fi

      # PadoEclipse
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "padoeclipse" ]; then
         PRODUCT_NAME="PadoEclipse"
         PRODUCT_DOWNLOAD_VERSIONS=("${PADOECLIPSE_DOWNLOAD_VERSIONS[@]}")
         if [ ${#PRODUCT_DOWNLOAD_VERSIONS[@]} -gt 0 ]; then
         INSTALLED_VERSIONS=$PADOECLIPSE_VERSIONS
         echo -e "PadoEclipse ${CUrl}$PADOECLIPSE_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         PADOECLIPSE_VERSION=$INSTALL_VERSION
         echo ""
         fi
      fi

      # Geode
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "geode" ]; then
         PRODUCT_NAME="Geode"
         PRODUCT_DOWNLOAD_VERSIONS=("${GEODE_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$GEODE_VERSIONS
         echo -e "Geode ${CUrl}$GEODE_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         GEODE_VERSION=$INSTALL_VERSION
         echo ""
      fi
      
      # Hazelcast Enterprise
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-enterprise" ]; then
         PRODUCT_NAME="Hazelcast Enterprise"
         PRODUCT_DOWNLOAD_VERSIONS=("${HAZELCAST_ENTERPRISE_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$HAZELCAST_ENTERPRISE_VERSIONS
         echo -e "Hazelcast Enterprise ${CUrl}$HAZELCAST_ENTERPRISE_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         HAZELCAST_ENTERPRISE_VERSION=$INSTALL_VERSION
         echo ""
      fi
      
      # Hazelcast OSS
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-oss" ]; then
         PRODUCT_NAME="Hazelcast OSS"
         PRODUCT_DOWNLOAD_VERSIONS=("${HAZELCAST_OSS_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$HAZELCAST_OSS_VERSIONS
         echo -e "Hazelcast OSS ${CUrl}$HAZELCAST_OSS_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         HAZELCAST_OSS_VERSION=$INSTALL_VERSION
         echo ""
      fi
      
      # Hazelcast Management Center
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-mc" ]; then
         PRODUCT_NAME="Hazelcast Management Center"
         PRODUCT_DOWNLOAD_VERSIONS=("${HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$HAZELCAST_MANAGEMENT_CENTER_VERSIONS
         echo -e "Hazelcast Management Center ${CUrl}$HAZELCAST_MANAGEMENT_CENTER_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         HAZELCAST_MANAGEMENT_CENTER_VERSION=$INSTALL_VERSION
         echo ""
      fi

      # HazelcastDesktop
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hazelcast-desktop" ]; then
         PRODUCT_NAME="HazelcastDesktop"
         PRODUCT_DOWNLOAD_VERSIONS=("${HAZELCAST_DESKTOP_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$HAZELCAST_DESKTOP_VERSIONS
         echo -e "HazelcastDesktop ${CUrl}$HAZELCAST_DESKTOP_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         HAZELCAST_DESKTOP_VERSION=$INSTALL_VERSION
         echo ""
      fi

      # Redis
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "redis-oss" ]; then
         PRODUCT_NAME="Redis"
         PRODUCT_DOWNLOAD_VERSIONS=("${REDIS_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$REDIS_VERSIONS
         echo -e "Redis ${CUrl}$REDIS_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         REDIS_VERSION=$INSTALL_VERSION
         echo ""
      fi
      
      # SnappyData
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "snappydata" ]; then
         PRODUCT_NAME="SnappyData"
         PRODUCT_DOWNLOAD_VERSIONS=("${SNAPPYDATA_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$SNAPPYDATA_VERSIONS
         echo -e "SnappyData ${CUrl}$SNAPPYDATA_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         SNAPPYDATA_VERSION=$INSTALL_VERSION
         echo ""
      fi
      
      # Spark
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "spark" ]; then
         PRODUCT_NAME="Spark"
         PRODUCT_DOWNLOAD_VERSIONS=("${SPARK_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$SPARK_VERSIONS
         echo -e "Spark ${CUrl}$SPARK_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         SPARK_VERSION=$INSTALL_VERSION
         
         # Allow the user to select a prebuilt spark distribution.
         INSTALLED_VERSIONS=($SPARK_VERSIONS)
         if [ "$SPARK_VERSION" != "" ]; then
            SPARK_PREBUILT_VERSIONS_ARRAY=(${SPARK_VERSION} $(getPrebuiltSparkVersions "$SPARK_VERSION"))
            __LEN=${#SPARK_PREBUILT_VERSIONS_ARRAY[@]}
            let __LAST_INDEX=__LEN-1
            __LOOP=true
            __INSTALLED="false"
            while [ "$__LOOP" == "true" ]; do
               __INDEX=0
               echo -e "Spark distributions ${CUrl}${SPARK_DOWNLOAD_URL}spark-$SPARK_VERSION/${CNone}"
               for i in ${SPARK_PREBUILT_VERSIONS_ARRAY[@]}; do
                  __INSTALLED="false"
                  for j in ${INSTALLED_VERSIONS[@]}; do
                     if [ "$i" == "$j" ]; then
                        __INSTALLED="true"
                        break;
                     fi
                  done
                  if [ "$__INSTALLED" == "true" ]; then
                     if [ $__INDEX -eq 0 ]; then
                        echo "   [$__INDEX] $i [installed] - source only (build may be required)"
                     else
                        echo "   [$__INDEX] $i [installed]"
                     fi
                  else
                     if [ $__INDEX -eq 0 ]; then
                        echo "   [$__INDEX] $i - source only (build required)"
                     else
                        echo "   [$__INDEX] $i"
                     fi
                  fi
                  let __INDEX=__INDEX+1
               done
               read -p "Enter a distribution to install or leave blank to skip: " INPUT
               if [ "$INPUT" == "" ]; then
                  break;
               else
                  if [ "$(isNumber $INPUT)" == "true" ]; then
                     if [ $INPUT -lt 0 ] || [ $INPUT -gt $__LAST_INDEX ]; then
                        echo "Invalid number. Enter [0, $__LAST_INDEX]."
                        continue;
                     fi
                  fi
                  SPARK_DIST_VERSION=${SPARK_PREBUILT_VERSIONS_ARRAY[$INPUT]}
                  echo -e "Spark selected: ${CGo}$SPARK_DIST_VERSION${CNone}"
                  __LOOP="false"
               fi
            done
         fi
         echo ""
      fi

      # Kafka
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "kafka" ]; then
         PRODUCT_NAME="Kafka"
         PRODUCT_DOWNLOAD_VERSIONS=("${KAFKA_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$KAFKA_VERSIONS
         echo -e "Kafka ${CUrl}$KAFKA_DOWNLOAD_URL${CNone}"
         echo -e "(PadoGrid currently ${CGo}supports only Kafka 2.8.0 and above.${CNone} Unsupported versions require manual management.)"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         KAFKA_VERSION=$INSTALL_VERSION

         # Allow the user to select a kafka distribution. (Scala versions)
         INSTALLED_VERSIONS=($KAFKA_VERSIONS)
         if [ "$KAFKA_VERSION" != "" ]; then
            KAFKA_SCALA_VERSIONS_ARRAY=($(getScalaKafkaVersions "$KAFKA_VERSION"))
            __LEN=${#KAFKA_SCALA_VERSIONS_ARRAY[@]}
            let __LAST_INDEX=__LEN-1
            __LOOP=true
            __INSTALLED="false"
            while [ "$__LOOP" == "true" ]; do
               __INDEX=0
               echo -e "Kafka distributions ${CUrl}${KAFKA_DOWNLOAD_URL}$KAFKA_VERSION/${CNone}"
               for i in ${KAFKA_SCALA_VERSIONS_ARRAY[@]}; do
                  __INSTALLED="false"
                  for j in ${INSTALLED_VERSIONS[@]}; do
                     if [ "$i" == "$j" ]; then
                        __INSTALLED="true"
                        break;
                     fi
                  done
                  if [ "$__INSTALLED" == "true" ]; then
                        echo "   [$__INDEX] $i [installed]"
                  else
                     echo "   [$__INDEX] $i"
                  fi
                  let __INDEX=__INDEX+1
               done
               read -p "Enter a distribution to install or leave blank to skip: " INPUT
               if [ "$INPUT" == "" ]; then
                  break;
               else
                  if [ "$(isNumber $INPUT)" == "true" ]; then
                     if [ $INPUT -lt 0 ] || [ $INPUT -gt $__LAST_INDEX ]; then
                        echo "Invalid number. Enter [0, $__LAST_INDEX]."
                        continue;
                     fi
                  fi
                  KAFKA_DIST_VERSION=${KAFKA_SCALA_VERSIONS_ARRAY[$INPUT]}
                  echo -e "Kafka selected: ${CGo}$KAFKA_DIST_VERSION${CNone}"
                  __LOOP="false"
               fi
            done
         fi
      fi

      # Kafka Confluent
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "confluent" ]; then
         PRODUCT_NAME="Confluent"
         PRODUCT_DOWNLOAD_VERSIONS=("${CONFLUENT_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$CONFLUENT_VERSIONS
         echo -e "Confluent ${CUrl}$CONFLUENT_DOWNLOAD_URL${CNone}"
         echo -e "(PadoGrid currently ${CGo}supports only Confluent 7.0 and above.${CNone} Unsupported versions require manual management.)"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         CONFLUENT_DIST_VERSION=$INSTALL_VERSION
         CONFLUENT_VERSION=$(echo $CONFLUENT_DIST_VERSION | sed 's/.*-//')
         echo ""
      fi

      # Hadoop
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "hadoop" ]; then
         PRODUCT_NAME="Hadoop"
         PRODUCT_DOWNLOAD_VERSIONS=("${HADOOP_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$HADOOP_VERSIONS
         echo -e "Hadoop ${CUrl}$HADOOP_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         HADOOP_VERSION=$INSTALL_VERSION
         echo ""
      fi
      
      # Prometheus
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "prometheus" ]; then
         PRODUCT_NAME="Prometheus"
         PRODUCT_DOWNLOAD_VERSIONS=("${PROMETHEUS_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$PROMETHEUS_VERSIONS
         echo -e "Prometheus ${CUrl}$PROMETHEUS_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         PROMETHEUS_VERSION=$INSTALL_VERSION
         echo ""
      fi

      # Grafana Enterprise
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "grafana-enterprise" ]; then
         PRODUCT_NAME="Grafana Enterprise"
         PRODUCT_DOWNLOAD_VERSIONS=("${GRAFANA_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$GRAFANA_ENTERPRISE_VERSIONS
         echo -e "Grafana Enterprise ${CUrl}$GRAFANA_GITHUB_RELEASES_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         GRAFANA_ENTERPRISE_VERSION=$INSTALL_VERSION
         echo ""
      fi

      # Grafana OSS
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "grafana-oss" ]; then
         PRODUCT_NAME="Grafana OSS"
         if [ "$GRAFANA_VERSIONS" == "" ]; then
            PRODUCT_DOWNLOAD_VERSIONS=("${GRAFANA_DOWNLOAD_VERSIONS[@]}")
            INSTALLED_VERSIONS=$GRAFANA_OSS_VERSIONS
         fi
         echo -e "Grafana OSS ${CUrl}$GRAFANA_GITHUB_RELEASES_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         GRAFANA_OSS_VERSION=$INSTALL_VERSION
         echo ""
      fi

      # Derby
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "derby" ]; then
         PRODUCT_NAME="Derby"
         PRODUCT_DOWNLOAD_VERSIONS=("${DERBY_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$DERBY_VERSIONS
         echo -e "Derby ${CUrl}$DERBY_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         DERBY_VERSION=$INSTALL_VERSION
         echo ""
      fi

      # Mosquitto
      if [ "$PRODUCT_ARG" == "" ] || [ "$PRODUCT_ARG" == "mosquitto" ]; then
         PRODUCT_NAME="Mosquitto"
         PRODUCT_DOWNLOAD_VERSIONS=("${MOSQUITTO_DOWNLOAD_VERSIONS[@]}")
         INSTALLED_VERSIONS=$MOSQUITTO_VERSIONS
         echo -e "Mosquitto ${CUrl}$MOSQUITTO_DOWNLOAD_URL${CNone}"
         doUserInput
         if [ "$INSTALL_VERSION" != "" ]; then
            let INSTALL_COUNT=INSTALL_COUNT+1
         fi
         MOSQUITTO_VERSION=$INSTALL_VERSION
         echo ""
      fi

      echo ""

      if [ $INSTALL_COUNT -eq 0 ]; then
         echo "You have not selected any products to install."
      else
         echo "You have selected the following versions to install:"
      fi

      if [ "$PADOGRID_VERSION" != "" ]; then
         echo -e "Padogrid: ${CGo}$PADOGRID_VERSION${CNone}"
      fi
      if [ "$PADO_VERSION" != "" ]; then
         echo -e "Pado: ${CGo}$PADO_VERSION${CNone}"
      fi
      if [ "$PADODESKTOP_VERSION" != "" ]; then
         echo -e "PadoDesktop: ${CGo}$PADODESKTOP_VERSION${CNone}"
      fi
      if [ "$PADOWEB_VERSION" != "" ]; then
         echo -e "PadoWeb: ${CGo}$PADOWEB_VERSION${CNone}"
      fi
      if [ "$PADOECLIPSE_VERSION" != "" ]; then
         echo -e "PadoEclipse: ${CGo}$PADOECLIPSE_VERSION${CNone}"
      fi
      if [ "$GEODE_VERSION" != "" ]; then
         echo -e "Geode: ${CGo}$GEODE_VERSION${CNone}"
      fi
      if [ "$HAZELCAST_ENTERPRISE_VERSION" != "" ]; then
         echo -e "Hazelcast Enterprise: ${CGo}$HAZELCAST_ENTERPRISE_VERSION${CNone}"
      fi
      if [ "$HAZELCAST_OSS_VERSION" != "" ]; then
         echo -e "Hazelcast OSS: ${CGo}$HAZELCAST_OSS_VERSION${CNone}"
      fi
      if [ "$HAZELCAST_MANAGEMENT_CENTER_VERSION" != "" ]; then
         echo -e "Hazelcast Management Center: ${CGo}$HAZELCAST_MANAGEMENT_CENTER_VERSION${CNone}"
      fi
      if [ "$HAZELCAST_DESKTOP_VERSION" != "" ]; then
         echo -e "HazelcastDesktop: ${CGo}$HAZELCAST_DESKTOP_VERSION${CNone}"
      fi
      if [ "$REDIS_VERSION" != "" ]; then
         echo -e "Redis: ${CGo}$REDIS_VERSION${CNone}"
      fi
      if [ "$SNAPPYDATA_VERSION" != "" ]; then
         echo -e "SnappyData: ${CGo}$SNAPPYDATA_VERSION${CNone}"
      fi
      if [ "$SPARK_VERSION" != "" ] && [ "$SPARK_DIST_VERSION" != "" ]; then
         echo -e "Spark: ${CGo}$SPARK_DIST_VERSION${CNone}"
      fi
      if [ "$KAFKA_VERSION" != "" ]; then
         echo -e "Kafka: ${CGo}$KAFKA_DIST_VERSION${CNone}"
      fi
      if [ "$CONFLUENT_VERSION" != "" ]; then
         echo -e "Kafka Confluent: ${CGo}$CONFLUENT_DIST_VERSION${CNone}"
      fi
      if [ "$HADOOP_VERSION" != "" ]; then
         echo -e "Hadoop: ${CGo}$HADOOP_VERSION${CNone}"
      fi
      if [ "$PROMETHEUS_VERSION" != "" ]; then
         echo -e "Prometheus: ${CGo}$PROMETHEUS_VERSION${CNone}"
      fi
      if [ "$GRAFANA_ENTERPRISE_VERSION" != "" ]; then
         echo -e "Grafana Enterprise: ${CGo}$GRAFANA_ENTERPRISE_VERSION${CNone}"
      fi
      if [ "$GRAFANA_OSS_VERSION" != "" ]; then
         echo -e "Grafana OSS: ${CGo}$GRAFANA_OSS_VERSION${CNone}"
      fi
      if [ "$DERBY_VERSION" != "" ]; then
         echo -e "Derby: ${CGo}$DERBY_VERSION${CNone}"
      fi
      if [ "$MOSQUITTO_VERSION" != "" ]; then
         echo -e "Mosquitto: ${CGo}$MOSQUITTO_VERSION${CNone}"
      fi
      echo ""

      REDO=true
      INNER_LOOP=true
      while [ "$INNER_LOOP" == "true" ]; do
         read -p "Enter 'c' to continue, 'r' to re-enter, 'q' to quit: " INPUT
         case $INPUT in
            [Cc]* ) REDO=false; INNER_LOOP=false;;
            [Rr]* ) REDO=true; INNER_LOOP=false;;
            [Qq]* ) echo "Command Aborted."; INNER_LOOP=false; exit;;
         esac
      done

   done

fi

# Set the padogrid paths again in case PADOGRID_ENV_BASE_PATH is changed interactively
PADOGRID_DOWNLOADS_PATH="$PADOGRID_ENV_BASE_PATH/downloads"
PADOGRID_PRODUCTS_PATH="$PADOGRID_ENV_BASE_PATH/products"
PADOGRID_SNAPSHOTS_PATH="$PADOGRID_ENV_BASE_PATH/snapshots"
PADOGRID_WORKSPACES_PATH="$PADOGRID_ENV_BASE_PATH/workspaces"

if [ "$FILE_SPECIFIED" != "true" ] && [ "$QUIET" == "false" ] && [ $INSTALL_COUNT -eq 0 ]; then
   echo ""
   echo "Product installation canceled. No products selected."
   echo ""
elif [ "$FILE_SPECIFIED" != "true" ]; then
   echo ""
   echo "Installing PadoGrid products... Some products may take a long time to download. Please wait."
   echo ""
fi

#
# Install user-entered versions
#

# downloads
if [ ! -d "$PADOGRID_DOWNLOADS_PATH" ]; then
   mkdir -p "$PADOGRID_DOWNLOADS_PATH"
fi

# products
if [ ! -d "$PADOGRID_PRODUCTS_PATH" ]; then
   mkdir -p "$PADOGRID_PRODUCTS_PATH"
fi

# snapshots
if [ ! -d "$PADOGRID_SNAPSHOTS_PATH" ]; then
   mkdir -p "$PADOGRID_SNAPSHOTS_PATH"
fi

# workspaces (RWEs)
if [ ! -d "$PADOGRID_WORKSPACES_PATH" ]; then
   mkdir -p "$PADOGRID_WORKSPACES_PATH"
fi

if [ "$SIMULATE" == "true" ]; then
   echo -e "${CBrownOrange}Simulation Only. You have specified the '-simulate' option. The curl commands printed"
   echo -e "below are for your information and the files are acutally NOT downloaded.${CNone}"
   echo ""
fi

if [ "$FILE_SPECIFIED" == "true" ]; then
   # Install Padogrid using the specified file
   tar -C "$PADOGRID_PRODUCTS_PATH" -xzf "$FILE_ARG"
   QUIET="true"
elif [ "$PADOGRID_VERSION" != "" ]; then
   PADOGRID_RELEASE="padogrid_$PADOGRID_VERSION"
   PADOGRID_TARBALL="$PADOGRID_RELEASE.tar.gz"
   installProduct "padogrid" "$SIMULATE"
fi
if [ "$PADO_VERSION" != "" ]; then
   #PADODESKTOP_RELEASE="pado_$PADO_VERSION"
   PADO_RELEASE="${PADO_VERSION#*/}"
   PADO_TARBALL="padogrid_$PADO_VERSION.tar.gz"
   installProduct "pado" "$SIMULATE"
fi
if [ "$PADODESKTOP_VERSION" != "" ]; then
   #PADODESKTOP_RELEASE="pado-desktop_$PADODESKTOP_VERSION"
   PADODESKTOP_RELEASE="${PADODESKTOP_VERSION#*/}"
   PADODESKTOP_TARBALL="padogrid_$PADODESKTOP_VERSION.tar.gz"
   installProduct "padodesktop" "$SIMULATE"
fi
if [ "$PADOWEB_VERSION" != "" ]; then
   #PADOWEB_RELEASE="padoweb_$PADOWEB_VERSION"
   PADOWEB_RELEASE="${PADOWEB_VERSION#*/}"
   PADOWEB_TARBALL="padogrid_$PADOWEB_VERSION.tar.gz"
   installProduct "padoweb" "$SIMULATE"
fi
if [ "$PADOECLIPSE_VERSION" != "" ]; then
   #PADOECLIPSE_RELEASE="com.netcrest.pado.eclipse_$PADOECLIPSE_VERSION"
   PADOECLIPSE_RELEASE="${PADOECLIPSE_VERSION#*/}"
   PADOECLIPSE_JAR="padogrid_$PADOECLIPSE_VERSION.jar"
   installProduct "padoeclipse" "$SIMULATE"
fi
if [ "$GEODE_VERSION" != "" ]; then
   GEODE_RELEASE="apache-geode-$GEODE_VERSION"
   GEODE_TARBALL="$GEODE_RELEASE.tgz"
   installProduct "geode" "$SIMULATE"
fi
if [ "$HAZELCAST_ENTERPRISE_VERSION" != "" ]; then
   HAZELCAST_ENTERPRISE_RELEASE="hazelcast-enterprise-$HAZELCAST_ENTERPRISE_VERSION"
   HAZELCAST_ENTERPRISE_TARBALL="$HAZELCAST_ENTERPRISE_RELEASE.tar.gz"
   installProduct "hazelcast-enterprise" "$SIMULATE"
fi
if [ "$HAZELCAST_OSS_VERSION" != "" ]; then
   HAZELCAST_OSS_RELEASE="hazelcast-$HAZELCAST_OSS_VERSION"
   HAZELCAST_OSS_TARBALL="$HAZELCAST_OSS_RELEASE.tar.gz"
   installProduct "hazelcast-oss" "$SIMULATE"
fi
if [ "$HAZELCAST_MANAGEMENT_CENTER_VERSION" != "" ]; then
   HAZELCAST_MC_RELEASE="hazelcast-management-center-$HAZELCAST_MANAGEMENT_CENTER_VERSION"
   HAZELCAST_MC_TARBALL="$HAZELCAST_MC_RELEASE.tar.gz"
   installProduct "hazelcast-management-center" "$SIMULATE"
fi
if [ "$HAZELCAST_DESKTOP_VERSION" != "" ]; then
   HAZELCAST_DESKTOP_RELEASE="hazelcast-desktop_$HAZELCAST_DESKTOP_VERSION"
   HAZELCAST_DESKTOP_TARBALL="$HAZELCAST_DESKTOP_RELEASE.tar.gz"
   installProduct "hazelcast-desktop" "$SIMULATE"
fi
if [ "$REDIS_VERSION" != "" ]; then
   REDIS_RELEASE="redis-$REDIS_VERSION"
   REDIS_TARBALL="$REDIS_RELEASE.tar.gz"
   installProduct "redis-oss" "$SIMULATE"
fi
if [ "$SNAPPYDATA_VERSION" != "" ]; then
   SNAPPYDATA_RELEASE="snappydata-$SNAPPYDATA_VERSION"
   SNAPPYDATA_TARBALL="$SNAPPYDATA_RELEASE.tar.gz"
   installProduct "snappydata" "$SIMULATE"
fi
if [ "$SPARK_VERSION" != "" ] && [ "$SPARK_DIST_VERSION" != "" ]; then
   SPARK_RELEASE="spark-$SPARK_VERSION"
   SPARK_TARBALL="spark-$SPARK_DIST_VERSION.tgz"
   installProduct "spark" "$SIMULATE"
fi
if [ "$KAFKA_VERSION" != "" ] && [ "$KAFKA_DIST_VERSION" != "" ]; then
   KAFKA_RELEASE="$KAFKA_VERSION"
   KAFKA_TARBALL="kafka_$KAFKA_DIST_VERSION.tgz"
   installProduct "kafka" "$SIMULATE"
fi
if [ "$CONFLUENT_VERSION" != "" ] && [ "$CONFLUENT_DIST_VERSION" != "" ]; then
   # Minor version
   CONFLUENT_MINOR_VERSION=$(echo $CONFLUENT_VERSION | awk -F. '{printf "%s.%s", $1, $2}')
   CONFLUENT_TARBALL="$CONFLUENT_DIST_VERSION.tar.gz"
   installProduct "confluent" "$SIMULATE"
fi
if [ "$HADOOP_VERSION" != "" ]; then
   HADOOP_RELEASE="hadoop-$HADOOP_VERSION"
   HADOOP_TARBALL="hadoop-$HADOOP_VERSION.tar.gz"
   installProduct "hadoop" "$SIMULATE"
fi
if [ "$PROMETHEUS_VERSION" != "" ]; then
   if [ "$HARDWARE_NAME" == "x86_64" ]; then
      POSTFIX=".$OS_NAME-amd64"
   elif [ "$HARDWARE_NAME" == "aarch64" ]; then
      POSTFIX=".$OS_NAME-arm64"
   else
      POSTFIX=".$OS_NAME-$HARDWARE_NAME"
   fi
   PROMETHEUS_RELEASE="prometheus-$PROMETHEUS_VERSION${POSTFIX}"
   PROMETHEUS_TARBALL="$PROMETHEUS_RELEASE.tar.gz"
   installProduct "prometheus" "$SIMULATE"
fi
if [ "$GRAFANA_ENTERPRISE_VERSION" != "" ]; then
   if [ "$HARDWARE_NAME" == "x86_64" ]; then
      POSTFIX=".$OS_NAME-amd64"
   elif [ "$HARDWARE_NAME" == "aarch64" ]; then
      POSTFIX=".$OS_NAME-arm64"
   else
      POSTFIX=".$OS_NAME-$HARDWARE_NAME"
   fi
   GRAFANA_ENTERPRISE_RELEASE="grafana-enterprise-$GRAFANA_ENTERPRISE_VERSION${POSTFIX}"
   GRAFANA_ENTERPRISE_TARBALL="$GRAFANA_ENTERPRISE_RELEASE.tar.gz"
   installProduct "grafana-enterprise" "$SIMULATE"
fi
if [ "$GRAFANA_OSS_VERSION" != "" ]; then
   if [ "$HARDWARE_NAME" == "x86_64" ]; then
      POSTFIX=".$OS_NAME-amd64"
   elif [ "$HARDWARE_NAME" == "aarch64" ]; then
      POSTFIX=".$OS_NAME-arm64"
   else
      POSTFIX=".$OS_NAME-$HARDWARE_NAME"
   fi
   GRAFANA_OSS_RELEASE="grafana-$GRAFANA_OSS_VERSION${POSTFIX}"
   GRAFANA_OSS_TARBALL="$GRAFANA_OSS_RELEASE.tar.gz"
   installProduct "grafana-oss" "$SIMULATE"
fi
if [ "$DERBY_VERSION" != "" ]; then
   DERBY_RELEASE="$DERBY_VERSION"
   DERBY_TARBALL="$DERBY_RELEASE-bin.tar.gz"
   installProduct "derby" "$SIMULATE"
fi
if [ "$MOSQUITTO_VERSION" != "" ]; then
   MOSQUITTO_RELEASE="$MOSQUITTO_VERSION"
   MOSQUITTO_TARBALL="mosquitto-$MOSQUITTO_RELEASE.tar.gz"
   installProduct "mosquitto" "$SIMULATE"
fi

# OS_NAME in uppercase
OS_NAME=`uname`
OS_NAME=`echo "$OS_NAME"|awk '{print toupper($0)}'`

# Mosquitto distribution contains source code only. Tell the user how to build.
if [ "$MOSQUITTO_VERSION" != "" ]; then
   echo ""
   echo "Mosquitto downloads do not include binaries. You can build binaries by"
   echo "following the steps below."
   echo ""
   if [ "$OS_NAME" == "DARWIN" ]; then
      echo -e "macOS:"
      echo -e "   ${CGo}cd $PADOGRID_PRODUCTS_PATH/mosquitto-$MOSQUITTO_RELEASE${CNone}"
      echo -e "   ${CGo}export OPENSSL_ROOT_DIR=/usr/local/opt/openssl${CNone}"
      echo -e "   ${CGo}cmake install -DDOCUMENTATION=NO -DWITH_PLUGINS=NO -DWITH_WEBSOCKETS=YES .${CNone}"
      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"
   else
      echo -e "Linux (Debian, Ubuntu):"
      echo -e "   ${CGo}cd $PADOGRID_PRODUCTS_PATH/mosquitto-$MOSQUITTO_RELEASE${CNone}"
      echo -e "   ${CGo}sudo apt install -y g++ libc-ares-dev libssl-dev libcjson-dev libwebsockets-dev${CNone}"
      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"
      echo ""
      echo -e "Linux (Alpine):"
      echo -e "   ${CGo}cd $PADOGRID_PRODUCTS_PATH/mosquitto-$MOSQUITTO_RELEASE${CNone}"
      echo -e "   ${CGo}sudo apk add g++ c-ares openssl-dev libwebsockets-dev${CNone}"
      echo -e "   ${CGo}sudo apk add make cmake git${CNone}"
      echo -e "   ${CGo}git clone https://github.com/DaveGamble/cJSON.git${CNone}"
      echo -e "   ${CGo}cd cJSON${CNone}"
      echo -e "   ${CGo}mkdir build${CNone}"
      echo -e "   ${CGo}cd build${CNone}"
      echo -e "   ${CGo}cmake ..${CNone}"
      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"

      echo -e "   ${CGo}sudo vi /etc/ld.so.conf${CNone}"
      echo -e "   # Add the following line in /etc/ld.so.conf:"
      echo -e "      /usr/local/lib64"
      echo -e "   ${CGo}cd ..${CNone}"

      echo -e "   ${CGo}vi config.mk${CNone}"
      echo -e "   # Enable websockets in config.mk"
      echo -e "      WITH_WEBSOCKETS:=yes"

      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"
      echo ""

      echo -e "Linux (RedHat,Oracle Linux, Fedora, CentOS):"
      echo -e "   ${CGo}cd $PADOGRID_PRODUCTS_PATH/mosquitto-$MOSQUITTO_RELEASE${CNone}"
      echo -e "   ${CGo}sudo dnf install -y cmake gcc-c++ openssl-devel c-ares-devel${CNone}"
      echo -e "   ${CGo}git clone https://github.com/DaveGamble/cJSON.git${CNone}"
      echo -e "   ${CGo}cd cJSON${CNone}"
      echo -e "   ${CGo}mkdir build${CNone}"
      echo -e "   ${CGo}cd build${CNone}"
      echo -e "   ${CGo}cmake ..${CNone}"
      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"
      echo -e "   ${CGo}sudo vi /etc/ld.so.conf${CNone}"
      echo -e "   # Add the following line in /etc/ld.so.conf:"
      echo -e "      /usr/local/lib64"
      echo -e "   ${CGo}sudo /sbin/ldconfig${CNone}"
      echo -e "   ${CGo}cd ../..${CNone}"
      echo -e "   ${CGo}git clone https://github.com/warmcat/libwebsockets.git${CNone}"
      echo -e "   ${CGo}cd libwebsockets${CNone}"
      echo -e "   ${CGo}cmake .${CNone}"
      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"
      echo -e "   ${CGo}cd ..${CNone}"

      echo -e "   ${CGo}vi config.mk${CNone}"
      echo -e "   # Enable websockets in config.mk"
      echo -e "      WITH_WEBSOCKETS:=yes"

      echo -e "   ${CGo}make${CNone}"
      echo -e "   ${CGo}sudo make install${CNone}"
   fi
   echo ""
   echo "If you are unable to build, then you can install a binary package by following"
   echo "the instructions in the following link:"
   echo ""
   echo -e "   ${CUrl}https://mosquitto.org/download/${CNone}"
fi

# Redis distribution contains source code only. Tell the user how to build.
if [ "$REDIS_VERSION" != "" ]; then
   echo ""
   echo "Redis OSS downloads do not include binaries. You can build binaries by"
   echo -e "running ${CGo}make${CNone} as follows."
   echo ""
   echo -e "   ${CGo}pushd $PADOGRID_PRODUCTS_PATH/$REDIS_RELEASE/deps && make hiredis lua jemalloc linenoise && pushd .. && make && popd && popd ${CNone}"
fi

# Check if an RWE exists in the workspaces dir
pushd $PADOGRID_WORKSPACES_PATH > /dev/null 2>&1
RWE_EXISTS="false"
for i in *; do
   if [ -d "$i" ]; then
      if [ -f "$i/initenv.sh" ]; then 
         RWE_EXISTS="true"
         break;
      fi
   fi
done
popd > /dev/null 2>&1

# If RWEs do not exist then create one
if [ "$RWE_EXISTS" == "false" ]; then
   __PADOGRID_HOME=""
   PADO_HOME=""
   PADODESKTOP_HOME=""
   PADOWEB_HOME=""
   GEODE_HOME=""
   HAZELCAST_MC_HOME=""
   HAZELCAST_DESKTOP_HOME=""
   HAZELCAST_HOME=""
   REDIS_HOME=""
   SNAPPYDATA_HOME=""
   SPARK_HOME=""
   KAFKA_HOME=""
   GEMFIRE_HOME=""
   COHERENCE_HOME=""
   PROMETHEUS_HOME=""
   GRAFANA_HOME=""
   DERBY_HOME=""
   MOSQUITTO_HOME=""

   # Set default workspaces home
   PADOGRID_WORKSPACES_HOME="$PADOGRID_ENV_BASE_PATH/workspaces/myrwe"

   # Find all installed products
   HAZELCAST_OSS_HOME=""
   pushd $PADOGRID_PRODUCTS_PATH > /dev/null 2>&1
   for i in *; do
     if [[ "$i" == **"padogrid_"** ]]; then
       __PADOGRID_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"pado_"** ]]; then
       PADO_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"pado-desktop_"** ]]; then
       PADODESKTOP_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"padoweb_"** ]]; then
       PADOWEB_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"geode"** ]]; then
       GEODE_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"hazelcast-enterprise"** ]]; then
       HAZELCAST_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"hazelcast-management-center"** ]]; then
       HAZELCAST_MC_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"hazelcast-desktop"** ]]; then
       HAZELCAST_DESKTOP_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"hazelcast"** ]]; then
       HAZELCAST_HOME="$PADOGRID_PRODUCTS_PATH/$i"
       HAZELCAST_OSS_HOME="$HAZELCAST_HOME"
     elif [[ "$i" == **"redis"** ]]; then
       REDIS_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"snappydata"** ]]; then
       SNAPPYDATA_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"spark"** ]]; then
       SPARK_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"kafka"** ]]; then
       KAFKA_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"confluent"** ]]; then
       KAFKA_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"gemfire"** ]]; then
       GEMFIRE_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"prometheus"** ]]; then
       PROMETHEUS_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"grafana"** ]]; then
       GRAFANA_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"derby"** ]]; then
       DERBY_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     elif [[ "$i" == **"mosquitto"** ]]; then
       MOSQUITTO_HOME="$PADOGRID_PRODUCTS_PATH/$i"
#     elif [[ "$i" == **"coherence"** ]]; then
#        COHERENCE_HOME="$PADOGRID_PRODUCTS_PATH/$i"
     fi
   done
   popd > /dev/null 2>&1

   # If Hazelcast Management Center is not installed then set it
   # to the management center included in the Hazelcast distribution.
   if [ "$HAZELCAST_MC_HOME" == "" ]; then
      if [ "$HAZELCAST_HOME" != "" ]; then 
          HAZELCAST_MC_HOME="$HAZELCAST_HOME/management-center"
      fi
   fi

   if [ -f "$__PADOGRID_HOME/bin_sh/create_rwe" ]; then
      echo "PadoGrid: $__PADOGRID_HOME"
      echo ""
      echo "Creating your first rwe in the specified PadoGrid environment..."
      echo ""

      TMP_ENV_FILE=/tmp/$EXECUTABLE-$(date "+%m%d%y%H%M%S").sh
      # product homes
      if [ "$HAZELCAST_OSS_HOME" != "" ]; then
         HAZELCAST_HOME="$HAZELCAST_OSS_HOME"
      fi
      if [ "$HAZELCAST_HOME" != "" ]; then
        PRODUCT_HOME="$HAZELCAST_HOME"
      elif [ "$GEODE_HOME" != "" ]; then
        PRODUCT_HOME="$GEODE_HOME"
      elif [ "$REDIS_HOME" != "" ]; then
        PRODUCT_HOME="$REDIS_HOME"
      elif [ "$SNAPPYDATA_HOME" != "" ]; then
        PRODUCT_HOME="$SNAPPYDATA_HOME"
      elif [ "$SPARK_HOME" != "" ]; then
        PRODUCT_HOME="$SPARK_HOME"
      elif [ "$KAFKA_HOME" != "" ]; then
        PRODUCT_HOME="$KAFKA_HOME"
      elif [ "$CONFLUENT_HOME" != "" ]; then
        PRODUCT_HOME="$CONFLUENT_HOME"
      elif [ "$GEMFIRE_HOME" != "" ]; then
        PRODUCT_HOME="$GEMFIRE_HOME"
      elif [ "$PROMETHEUS_HOME" != "" ]; then
        PRODUCT_HOME="$PROMETHEUS_HOME"
      elif [ "$GRAFANA_HOME" != "" ]; then
        PRODUCT_HOME="$GRAFANA_HOME"
      elif [ "$DERBY_HOME" != "" ]; then
        PRODUCT_HOME="$DERBY_HOME"
      elif [ "$MOSQUITTO_HOME" != "" ]; then
        PRODUCT_HOME="$MOSQUITTO_HOME"
      fi

      echo "PADOGRID_ENV_BASE_PATH=\"$PADOGRID_ENV_BASE_PATH\"" >> $TMP_ENV_FILE
      echo "PADOGRID_WORKSPACES_HOME=\"$PADOGRID_WORKSPACES_HOME\"" >> $TMP_ENV_FILE
      echo "PADO_HOME=\"$PADO_HOME\"" >> $TMP_ENV_FILE
      echo "PADODESKTOP_HOME=\"$PADODESKTOP_HOME\"" >> $TMP_ENV_FILE
      echo "PADOWEB_HOME=\"$PADOWEB_HOME\"" >> $TMP_ENV_FILE
      echo "GEODE_HOME=\"$GEODE_HOME\"" >> $TMP_ENV_FILE
      echo "HAZELCAST_HOME=\"$HAZELCAST_HOME\"" >> $TMP_ENV_FILE
      echo "HAZELCAST_MC_HOME=\"$HAZELCAST_MC_HOME\"" >> $TMP_ENV_FILE
      echo "HAZELCAST_DESKTOP_HOME=\"$HAZELCAST_DESKTOP_HOME\"" >> $TMP_ENV_FILE
      echo "MOSQUITTO_HOME=\"$MOSQUITTO_HOME\"" >> $TMP_ENV_FILE
      echo "REDIS_HOME=\"$REDIS_HOME\"" >> $TMP_ENV_FILE
      echo "SNAPPYDATA_HOME=\"$SNAPPYDATA_HOME\"" >> $TMP_ENV_FILE
      echo "SPARK_HOME=\"$SPARK_HOME\"" >> $TMP_ENV_FILE
      echo "KAFKA_HOME=\"$KAFKA_HOME\"" >> $TMP_ENV_FILE
      echo "GEMFIRE_HOME=\"$GEMFIRE_HOME\"" >> $TMP_ENV_FILE
      echo "COHERENCE_HOME=\"$COHERENCE_HOME\"" >> $TMP_ENV_FILE
      echo "HADDOP_HOME=\"$HADOOP_HOME\"" >> $TMP_ENV_FILE
      echo "PROMETHEUS_HOME=\"$PROMETHEUS_HOME\"" >> $TMP_ENV_FILE
      echo "GRAFANA_HOME=\"$GRAFANA_HOME\"" >> $TMP_ENV_FILE
      echo "DERBY_HOME=\"$DERBY_HOME\"" >> $TMP_ENV_FILE
      echo "MOSQUITTO_HOME=\"$MOSQUITTO_HOME\"" >> $TMP_ENV_FILE

      PADOGRID_OPTS=""
      if [ "$PRODUCT_HOME" != "" ]; then
         PADOGRID_OPTS="-product $PRODUCT_HOME"
      fi
      if [ "$QUIET" == "true" ]; then
         $__PADOGRID_HOME/bin_sh/create_rwe -workspace myws -quiet -rwe myrwe $PADOGRID_OPTS -env $TMP_ENV_FILE
      else
         $__PADOGRID_HOME/bin_sh/create_rwe -rwe myrwe -workspace myws $PADOGRID_OPTS -env $TMP_ENV_FILE 
      fi
      rm $TMP_ENV_FILE

      # Append padogrid initialization call in .bashrc if it does not exist
      PADOGRID_INIT_IN_BASHRC=$(grep initenv.sh $HOME/.bashrc)
      if [ "$PADOGRID_INIT_IN_BASHRC" == "" ]; then
         echo ""  >> $HOME/.bashrc
         echo "# >>> padogrid initialization >>>"  >> $HOME/.bashrc
         echo ". $PADOGRID_WORKSPACES_HOME/initenv.sh -quiet" >> $HOME/.bashrc
         echo "# <<< padogrid initialization <<<"  >> $HOME/.bashrc
         echo ""  >> $HOME/.bashrc
         echo "Appended the following padogrid initialization routine in '~/.bashrc'."
      else
         echo "Padogrid initialization routine already exist in '~/.bashrc'. To use the RWE created"
         echo "by this installation as the default RWE, add the following line in '~/.bashrc'."
      fi
      echo -e "${CGo}   . $PADOGRID_WORKSPACES_HOME/initenv.sh -quiet${CNone}"
   fi
fi

echo ""
echo "PadoGrid Installation complete."
echo ""