Install Redis on ubuntu

redis_installation_script.sh

#!/bin/bash


#TEMP_DIR="$(dirname $(mktemp -u))""/"
TEMP_DIR=$(mktemp -u)
DEFAULT_REDIS_VERSION="3.2.6"
DEFAULT_PORT="6379"
DEFAULT_PID_DIR="/var/run"

# Version to install
REDIS_VERSION=$DEFAULT_REDIS_VERSION

# Just a prefix which will be prefixed for all redis related dirs
PREFIX='/'

# To test under different directory, comment out next line and 
# run `mkdir` command next to it
#PREFIX='/tmp/abc/'

# Name of redis directory to be installed
REDIS_INSTALLATION_DIR="$PREFIX""usr/local"
# Conf file
REDIS_CONFIG_FILE_NAME="redis.conf"

REDIS_DATA_DIR="$PREFIX""var/lib/redis"
REDIS_DATA_FILE_NAME="dump.rdb"

REDIS_LOG_DIR="$PREFIX""var/log/redis"
REDIS_LOG_FILE_NAME='redis-license.log'

# Redis conf
REDIS_CONFIG_PARAM_RENAME_COMMANDS=0    # To rename commands like flushall, config, flushdb
REDIS_CONFIG_PARAM_PORT="$DEFAULT_PORT" # Port to run
REDIS_CONFIG_PARAM_PID_DIR="$DEFAULT_PID_DIR"      # To be calculated afterwards...
REDIS_CONFIG_PARAM_DAEMONIZE="yes"      # To run server redis as daemon
REDIS_CONFIG_PARAM_MAX_MEMORY='50mb'
REDIS_CONFIG_PARAM_NO_OF_DATABASES=4

ARGS="$@"

getDirectoryName() {
  local argDirName="$1"
  if [ "${argDirName: -1}" == "/" ]; then
    echo "${argDirName:0:-1}"
  else
    echo $argDirName
  fi
}

usage() {
  cat <<EOT
  Usage:
    --version                     : Redis Version (Default: $DEFAULT_REDIS_VERSION)
    --install-dir                 : Installation directory (Default: ${PREFIX}usr/local) Redis directory: /usr/local/redis-<version>
    --config-dir                  : Configuration directory name not relative to redis dir (Default: conf under redis dir)
    --config-file-name            : Configuration file name under config directory
    --data-dir                    : Data directory (Default: ${PREFIX}var/lib/redis)
    --data-file-name              : Data file name relative to data dir (Default: dump.rdb)
    --log-dir                     : Log directory (Default: ${PREFIX}var/log/redis)
    --log-file-name               : Log file name under log dir (Default: redis-license.log)
    --config-param-max-memory     : Maximum memory to allocate (Default: 50mb)
    --config-param-port           : Redis port (Default: $DEFAULT_PORT)
    --config-param-no-of-databases: No of databases to create (Default: 4)
    --config-param-no-daemonize   : To daemonize server process (Default: yes)
    -h|--help                     : Help
EOT
}

parseArgs() {
  OPTIND=1
  OPTS=`getopt -o h --long help,config-param-no-daemonize,version:,install-dir:,config-dir:,config-file-name:,data-dir:,data-file-name:,log-dir:,log-file-name:,config-param-max-memory:,config-param-no-of-databases:,config-param-port: -n 'parse-options' -- $ARGS`

  if [ $? != 0 ] ; then echo "Failed parsing options." >&2 ; exit 1 ; fi

  declare -A argsMap
  eval set -- "$OPTS"

  while true; do
    case "$1" in
      ( -h|--help                      ) shift; usage; exit 0; break ;;
      ( --version                      ) REDIS_VERSION="$2"; shift 2;;
      ( --install-dir                  ) REDIS_INSTALLATION_DIR="$2"; shift 2;;
      ( --config-dir                   ) REDIS_CONFIG_DIR=$(getDirectoryName "$2"); shift 2;;
      ( --config-file-name             ) REDIS_CONFIG_FILE_NAME="$2"; shift 2;;
      ( --data-dir                     ) REDIS_DATA_DIR=$(getDirectoryName "$2"); shift 2;;
      ( --data-file-name               ) REDIS_DATA_FILE_NAME="$2"; shift 2;;
      ( --log-dir                      ) REDIS_LOG_DIR=$(getDirectoryName "$2"); shift 2;;
      ( --log-file-name                ) REDIS_LOG_FILE_NAME="$2"; shift 2;;
      ( --config-param-max-memory      ) REDIS_CONFIG_PARAM_MAX_MEMORY="$2"; shift 2;;
      ( --config-param-port            ) REDIS_CONFIG_PARAM_PORT="$2"; shift 2;;
      ( --config-param-no-of-databases ) REDIS_CONFIG_PARAM_NO_OF_DATABASES="$2"; shift 2;;
      ( --config-param-no-daemonize    ) REDIS_CONFIG_PARAM_DAEMONIZE="no"; shift ;;
      ( --                             ) shift; break ;;
      ( *                              ) shift; break ;;
    esac
  done
  REDIS_INSTALL_DIR_NAME="redis-$REDIS_VERSION"
  REDIS_DIR="$REDIS_INSTALLATION_DIR/$REDIS_INSTALL_DIR_NAME"

  REDIS_CONFIG_DIR=${REDIS_CONFIG_DIR:-$REDIS_DIR/conf}
  REDIS_CONFIG_FILE="$REDIS_CONFIG_DIR/$REDIS_CONFIG_FILE_NAME"

  REDIS_DATA_FILE_PATH="$REDIS_DATA_DIR/$REDIS_DATA_FILE_NAME"
  REDIS_LOG_FILE="$REDIS_LOG_DIR/$REDIS_LOG_FILE_NAME"
  REDIS_CONFIG_PARAM_PID_DIR="$REDIS_DIR/pid"      # To be calculated afterwards...

  REDIS_TAR_FILE="redis-""$REDIS_VERSION"".tar.gz"
  REDIS_TAR_DOWNLOADED_FILE="$TEMP_DIR/$REDIS_TAR_FILE"
  REDIS_TAR_DOWNLOAD_URL="http://download.redis.io/releases/""$REDIS_TAR_FILE"
}

parseArgs

cat << EOF
Configuration Params :
  Redis version: $REDIS_VERSION
  Redis installation dir: $REDIS_DIR
  Redis Config file: $REDIS_CONFIG_FILE
  Redis data file: $REDIS_DATA_FILE_PATH
  Redis Log File: $REDIS_LOG_FILE
  Redis conf param:
    Daemonize: $REDIS_CONFIG_PARAM_DAEMONIZE
    Port: $REDIS_CONFIG_PARAM_PORT
    Pid directory: $REDIS_CONFIG_PARAM_PID_DIR
    Max memory: $REDIS_CONFIG_PARAM_MAX_MEMORY
    No of databases: $REDIS_CONFIG_PARAM_NO_OF_DATABASES

EOF

echo -e "Options OK ?
     #~~~~~~~~~~~~#
     | 1.) Yes    |
     | 2.) No     |
     #~~~~~~~~~~~~#\n"

read -e -p "Select: " choice
if [ "$choice" != "1" ]; then
  echo "Re-check the command and run again..."
  echo "GooD Luck...!!!"
  exit 7
fi
  #Download url: $REDIS_TAR_DOWNLOAD_URL
  #tar.gz dir: $REDIS_TAR_DOWNLOADED_FILE

### 1. Check redis version url ###
checkRedisVersionUrlExistence() {
  local redisUrlHttpCode=$(curl -s --head $REDIS_TAR_DOWNLOAD_URL | head -n 1 | cut -d' ' -f2)

  if [ $redisUrlHttpCode != "200" ]; then
    echo "Wrong redis version provided: $REDIS_VERSION"
    echo "Http Code: $redisUrlHttpCode"
    exit 1
  fi
}

### 2. Check redis version existence ###
checkRedisInstallationDirExistence() {
  if [ -d $REDIS_DIR ]; then
    echo "Redis installation directory '$REDIS_DIR' already present"
    exit 2
  fi
}

### 3. Check rdb data file
checkRedisRdbFileExistence() {
  if [ -f $REDIS_DATA_FILE_PATH ]; then
    echo "Redis data file '$REDIS_DATA_FILE_PATH' already present"
    exit 3
  fi
}

validateChecksum() {
  local checkSumA="$1"
  local checkSumB="$(sha1sum $2 | cut -d' ' -f 1)"
  if [ $checkSumA == $checkSumB ]; then
    echo "    Checksum VALID : OK"
    return 1;
  fi

  local bypassMismatch="$3"
  if [ -z "$bypassMismatch" ]; then
    echo "  Checksum VALID : FAIL"
    echo "  Orig Checksum : $checkSumA"
    echo "  Dwld Checksum : $checkSumB"
    exit 4
  else
    echo "  Checksum VALID : OK"
  fi
  return 0
}

getOriginalCheckSum() {
  echo $(curl -s https://github.com/antirez/redis-hashes/blob/master/README | \
    grep "hash $REDIS_TAR_FILE sha1" | \
     sed -e 's/.*tar.gz sha1 \(.*\)http:\/\/download.*/\1/')
}

downloadFile() {
  echo "Bringing redis..."
  local downloadFile=1
  local origSha1Checksum=$(getOriginalCheckSum)

  if [ -f "$REDIS_TAR_DOWNLOADED_FILE" ]; then
    echo "  File already present..."
    echo "    Validating checksum..."
    validateChecksum $origSha1Checksum $REDIS_TAR_DOWNLOADED_FILE 1
    # validation succeed
    if [ "$?" == 1 ]; then
      downloadFile=0
    else
      echo "    Checksum VALID : FAIL"
    fi
  fi

  if [ $downloadFile == 1 ]; then
    echo "  Downloading $REDIS_TAR_DOWNLOAD_URL"
    curl -# -o "$REDIS_TAR_DOWNLOADED_FILE" "$REDIS_TAR_DOWNLOAD_URL"
    validateChecksum $origSha1Checksum $REDIS_TAR_DOWNLOADED_FILE 
  fi
}

prepareRedisConfForRdb() {
  vmOvercommit=$(sudo sysctl vm.overcommit_memory)
  if [ "$vmOvercommit" == "vm.overcommit_memory = 0" ]; then
    echo "Running sysctl vm.overcommit_memory=1"
    sudo sysctl vm.overcommit_memory=1
  fi
}

prepareRedisConf() {
  # Make conf dir
  mkdir -p $REDIS_CONFIG_DIR
  cp redis.conf "$REDIS_CONFIG_FILE"

  ### sed world
  # memory for redis
  sed -r -i "s|^# maxmemory <bytes>|maxmemory $REDIS_CONFIG_PARAM_MAX_MEMORY|" $REDIS_CONFIG_FILE
  # set no of databases
  sed -r -i "s#^databases 16#databases $REDIS_CONFIG_PARAM_NO_OF_DATABASES#" $REDIS_CONFIG_FILE
  # set log file
  sed -r -i "s#^logfile \"\"#logfile \"$REDIS_LOG_FILE\"#" $REDIS_CONFIG_FILE


  # rds snapshot
  sed -r -i "s|^save 60 10000|save 60 1|" $REDIS_CONFIG_FILE
  sed -r -i "s|^save 900 1|#save 900 1|" $REDIS_CONFIG_FILE
  sed -r -i "s|^save 300 10|#save 300 10|" $REDIS_CONFIG_FILE
  # rdb data dir and filename
  sed -r -i "s#^dir ./#dir $REDIS_DATA_DIR#" $REDIS_CONFIG_FILE
  sed -r -i "s#^dbfilename dump.rdb#dbfilename $REDIS_DATA_FILE_NAME#" $REDIS_CONFIG_FILE
  # other rdb related config
  prepareRedisConfForRdb

  # AOF persistence
  sed -r -i "s#^appendonly no#appendonly yes#" $REDIS_CONFIG_FILE

  # Daemonize config
  if [ $REDIS_CONFIG_PARAM_DAEMONIZE == "yes" ]; then 
    sed -r -i "s|^daemonize no|daemonize yes|" $REDIS_CONFIG_FILE
  fi

  # set port if required
  if [ "$REDIS_CONFIG_PARAM_PORT" != $DEFAULT_PORT ]; then
    sed -r -i "s#^port $DEFAULT_PORT#port $REDIS_CONFIG_PARAM_PORT#" $REDIS_CONFIG_FILE
  fi

  # set pid file
  if [ "$REDIS_CONFIG_PARAM_PID_DIR" != "$DEFAULT_PID_DIR" ]; then
    sed -r -i "s#^pidfile.*#pidfile $REDIS_CONFIG_PARAM_PID_DIR/${REDIS_CONFIG_PARAM_PORT}.pid#" $REDIS_CONFIG_FILE
  fi

  #sed -r -i "s###" $REDIS_CONFIG_FILE
  #sed -r -i "s###" $REDIS_CONFIG_FILE
}

### 3. Check redis data dir ###
prepareDirsIfAbsent() {
  if [ ! -d $REDIS_DATA_DIR ]; then
    echo "Creating redis data dir '$REDIS_DATA_DIR'..."
    mkdir -p $REDIS_DATA_DIR
    echo "created"
  fi
  if [ ! -d $REDIS_LOG_DIR ]; then
    echo "Creating redis data dir '$REDIS_LOG_DIR'..."
    mkdir -p $REDIS_LOG_DIR
    echo "created"
  fi

  if [ "$REDIS_CONFIG_PARAM_PID_DIR" != "$DEFAULT_PID_DIR" ] && [ ! -d $REDIS_CONFIG_PARAM_PID_DIR ]; then
    echo "Creating pid directory '$REDIS_CONFIG_PARAM_PID_DIR'..."
    mkdir -p $REDIS_CONFIG_PARAM_PID_DIR
    echo "created"
  fi
}

freshInstall() {
  currDir=$PWD

  # Pre checks
  checkRedisVersionUrlExistence
  checkRedisInstallationDirExistence
  checkRedisRdbFileExistence

  mkdir -p $TEMP_DIR
  # download
  downloadFile

  # extract
  echo "Extract files from package..."
  tar -zxf $REDIS_TAR_DOWNLOADED_FILE -C $TEMP_DIR/
  echo "Extracted..."

  # Go into extracted directory
  cd $TEMP_DIR/$REDIS_INSTALL_DIR_NAME

  echo "Installing redis into $REDIS_DIR"
  make PREFIX=$REDIS_DIR --silent install
  if [ $? != 0 ]; then
    echo "Installation failed[$?]..."
    exit 5
  fi
  echo "Installed..."

  prepareRedisConf
  prepareDirsIfAbsent

  cat <<EOT
Run server using:
  $REDIS_DIR/bin/redis-server $REDIS_CONFIG_FILE
EOT
}

freshInstall