Da

✏️ Editing: redis_user_action.sh

#!/bin/bash

# redis_user_action: Performs action requested on user-redis.  Must be run escalated.
# Parameters:
# $1: action (list, enable, enablesetup, enableunsized, enablepkg, disable, disablesetup, disableunsized, disablepkg, cleanup, configdel, configupd, defaultsizeset, defaultsizeget, listdefaultusers, getdefaultenabled, getuseredis, setuseredis, setusevalkey
# if list: No additional parameters
# if cleanup: $2 UID only
# if configdel: No additional parameters
# if configupd: $2 CONFIGFILE only
# if defaultsizeset: $2 SIZE only (0 for delete)
# if enableunsized: Optional $2 to set/reset the default size.
# if disableunsized: No parameters
# if enablepkg or disablepkg: $2 package name (and for enablepkg there should be a size set in lspkgctl)
# if xxxuseredis or xxxusevalkey: No parameters
# $2: LswsHomeDir (action enablexxx or disablexxx)
# $3: user (action == enablexxx or disablexxx)
# $4: homedir (action == enablexxx or disablexxx)
# $5: size in MB (action == enablexxx or disablexxx)
# user and homedir can repeat in pairs.
# You can a STATUS_FILE=$x parameter as a prefix to action for async capable actions which are xxxpkg and xxxdefault

function reset_LSWS_HOME_vars()
{
  DEFAULT_SIZE_FILENAME="${LSWS_HOME}/lsns/conf/redis_default_size.conf"
  DEFAULT_USERS_ACTIVATE_FILENAME="${LSWS_HOME}/lsns/conf/default_users_redis_activate"
  CONF="${LSWS_HOME}/lsns/conf/redis_size.conf"
  PACKAGE_SIZE_FILE="${LSWS_HOME}/lsns/conf/redis_package_size.conf"
}

# Parameters
# $1 message to log
# $2 severity (as text)
function log()
{
    if [ "${2}" = "DEBUG" ] && [ ! -e "/usr/local/lsws/debug" ]; then
        return
    fi

echo "$(date --utc +"%F %H:%M:%S")" "[${2}]" "${1}" >> "${LSWS_HOME}/logs/webcachemgr.log"
}

function get_dir_filenames()
{
  # Must have HOMEDIR set, sets DIR, SIZEFILE and PACKAGEFILE
  if [[ -d "$HOMEDIR/.cagefs" ]]; then
    DIR="$HOMEDIR/.cagefs"
  else
    DIR="$HOMEDIR/.lsns"
  fi

SIZEFILE="${DIR}/tmp/redis/redis.size"
  PACKAGEFILE="${DIR}/tmp/redis/redis.package"
}

function get_homedir_filenames()
{
  # Must have USER set, sets DIR, SIZEFILE and PACKAGEFILE
  HOMEDIR=$(grep "^${USER}": < /etc/passwd|awk -F ':' '{print $6}')
  get_dir_filenames
}

function rm_size_dir_file()
{
  # Sets up the size directory file to be updated/deleted.  Must have SIZEFILE set
  if [ -e "${SIZEFILE}" ]; then
    chattr -i "${SIZEFILE}"
    rm "${SIZEFILE}"
  fi
}

function rm_package_dir_file()
{
  # Sets up the size directory file to be updated/deleted.  Must have PACKAGEFILE set
  if [ -e "${PACKAGEFILE}" ]; then
    chattr -i "${PACKAGEFILE}"
    rm "${PACKAGEFILE}"
  fi
}

function enable_svc()
{
  # Does the actual enable.  Must have USER set
  log "Activating Redis service for user: ${USER}" "INFO"

if ! $(systemctl start "user-redis@${USER}"); then
    echo "May indicate user is not in cage">&2
    log "Error starting service for user: ${USER}" "ERROR"
    exit 1
  fi

if ! $(systemctl enable "user-redis@${USER}"); then
    log "Error enabling service for user: ${USER}" "ERROR"
    exit 1
  fi
}

function disable_svc()
{
  # Does the actual disable.  Must have USER set
  log "Disabling Redis service for user: ${USER}" "INFO"

if ! $(systemctl stop "user-redis@${USER}"); then
    log "Error stopping service for user: ${USER}" "ERROR"
    exit 1
  fi

if ! $(systemctl disable "user-redis@${USER}"); then
    log "Error disabling service for user: ${USER}" "ERROR"
    exit 1
  fi
}

function mk_user_files()
{
  log "mk_user_files for user: ${USER}" "DEBUG"

if ! sudo -u "${USER}" mkdir -p "$DIR/tmp/redis"; then
    echo "Error $? in mkdir -p $DIR/tmp/redis"
    log "Error in mkdir for user: ${USER}" "ERROR"
    exit 1
  fi

if [ "${ACTION}" != "enablesvc" ]; then
    rm_size_dir_file
    sudo -u "${USER}" bash -c "echo ${SIZEMB} > ${SIZEFILE}"
    chmod 400 "${SIZEFILE}"
    chattr +i "${SIZEFILE}"
  fi

if PACKAGE=$("$LSWS_HOME"/lsns/bin/lspkgctl userpkg -q --user "$USER"); then
    rm_package_dir_file
    sudo -u "${USER}" bash -c "echo ${PACKAGE} > ${PACKAGEFILE}"
    chmod 400 "${PACKAGEFILE}"
    chattr +i "${PACKAGEFILE}"
  fi
}

function user_fn()
{
  if (( $# < 1)); then
    echo "Missing user in redis user script"
    exit 255
  fi

USER="$1"

if (( $# < 2)); then
    echo "Missing homedir in redis user script for $ACTION"
    exit 255
  fi

HOMEDIR=$2
  get_dir_filenames
  log "user_fn USER: $USER, HOMEDIR: $HOMEDIR, SIZEMB: $3, ACTION: $ACTION" "DEBUG"
  USERSTR="\"${USER}\","

if [[ $ACTION == "enable"* ]] ; then
    log "Activating Redis service for user: ${USER}" "INFO"

if (( $# < 3)); then
      echo "Missing redis size in redis user script for $ACTION"
      exit 255
    fi

SIZEMB=$3

if [ "${ACTION}" != "enablesvc" ]; then

if ! grep "$USERSTR" "${CONF}" >/dev/null 2>&1; then
        echo "${USERSTR}\"${SIZEMB}\"">>"${CONF}"
        PERM=$(stat -c "%a" "${CONF}")

if [ "${PERM}" != "600" ]; then
          chmod 600 "${CONF}"
        fi
      else
        sed -i "s/^${USERSTR}.*/${USERSTR}\"${SIZEMB}\"/" "${CONF}"
      fi
    fi

mk_user_files

if [ "${ACTION}" = "enable" ] || [ "${ACTION}" = "enablesvc" ]; then
      enable_svc
    fi
  else

if [ "${ACTION}" = "disable" ] || [ "${ACTION}" = "disablesvc" ]; then
      disable_svc
    fi

if [ "${ACTION}" = "disable" ] || [ "${ACTION}" = "disablesetup" ] || [ "${SIZEMB}" = "-1" ]; then
      log "Removed Redis setup for user: ${USER}" "INFO"

if [ -e "${PACKAGEFILE}" ]; then
        chattr -i "${PACKAGEFILE}"
        if [ $? -ne 0 ]; then
          log "Error in removing immutable attribute from ${PACKAGE_FILE}" "DEBUG"
        fi
      else
        log "Expected package file ${PACKAGEFILE} to exist." "DEBUG"
      fi

if [ -e "${SIZEFILE}" ]; then
        chattr -i "${SIZEFILE}"
      fi

rm -rf "$DIR/tmp/redis"
      sed -i "/^${USERSTR}.*/d" "${CONF}"
    fi
  fi
}

function is_user_size_set()
{
  # returns 0 if the user's size is set in the size file.  Must have USER set.
  if grep "\"${USER}\"," "${CONF}" >/dev/null 2>&1 ; then
    return 0
  fi

return 1
}

function is_package_size_set()
{
  # returns 0 if the user's size is defined in a package.  Must have USER set.
  if PACKAGE=$("$LSWS_HOME"/lsns/bin/lspkgctl userpkg -q --user "$USER"); then

if "$LSWS_HOME/lsns/bin/lspkgctl" -q list "${PACKAGE}" | grep \"size\" >/dev/null 2>&1; then
      return 0
    else
      log "is_package_size_set $USER, no size set" "DEBUG"
      return 1
    fi
  else
    log "is_package_size_set $USER, not in package" "DEBUG"
  fi

return 1
}

function is_default_size()
{
  # $1 is the USER
  USER="${1}"

if is_user_size_set; then
    return 1
  fi

if is_package_size_set; then
    return 1
  fi

return 0
}

function do_cleanupsvc_only()
{
  disable_svc
  get_homedir_filenames
  rm_size_dir_file
  rm_package_dir_file
  rm -rf "$DIR/tmp/redis"

return 0
}

function do_cleanupsvc()
{
  if do_cleanupsvc_only; then
    exit 1
  fi

USERSTR="\"${USER}\","

if is_user_size_set; then
    log "Removed Redis setup for user: ${USER}" "INFO"
    sed -i "/^${USERSTR}.*/d" "${CONF}"
  fi

exit 0
}

function do_cleanup()
{
  IN_UID="$1"

if ! PID=$(ps -e -O ruser:64|grep "[r]edis_svc"|grep "${IN_UID}"|awk -F ' ' '{print $1}'); then
    echo "The redis service for UID: ${IN_UID} was not found"
    exit 1
  fi

if ! USER=$(ps -e -O ruser:64|grep "[r]edis_svc"|grep "${IN_UID}"|awk -F ' ' '{print $9}'); then
    echo "The user for pid $PID was not found"
    exit 1
  fi

if [ "$USER" == "" ]; then
    #This appears to happen during some cleanup, don't panic!
    #echo "The user for pid $PID was missing"
    #exit 1
    return 0
  fi

if [ ! -e "/proc/$PID" ]; then
    echo "The PID $PID for UID $IN_UID stopped; unexpected error"
    exit 1
  fi

#if readlink -f "/proc/$PID/cwd"; then
  #  echo "The pid $PID with $IN_UID is still running, will not cleanup"
  #  exit 1
  #fi
  do_cleanupsvc
}

function restart_all_svcs()
{
  FILES=$(ls -1 /etc/systemd/system/multi-user\.target\.wants/user-redis*\.service 2>&1)
  if [ $? -ne 0 ]; then
    return 0
  fi
  COUNT=$(wc -l <<< "${FILES}")
  FILE_NUM=0

while IFS= read -r FILE; do
    FILE_NUM=$((FILE_NUM + 1))

if [ "${STATUS_FILE}" != '' ]; then
      echo -e "${FILE_NUM}\n${COUNT}" > "${STATUS_FILE}"
    fi

FILEONLY=$(basename "$FILE")
    systemctl restart "$FILEONLY"
  done <<< "${FILES}"
}

function get_serverline()
{
  # Any changes to the SERVER_LINE need to be reflected in the install so we can find the line
  SERVER_LINE='"/usr/bin/${REDIS}-server"'
}

function do_configdel()
{
  log "Deleting configuration file from service" "INFO"

if [ ! -f "${LSWS_HOME}/lsns/bin/redis_svc.sh" ]; then
    exit 0 # Not installed, nothing to do
  fi

get_serverline
  if ! CONFIG_NOW=$(grep ${SERVER_LINE} ${LSWS_HOME}/lsns/bin/redis_svc.sh | awk -F ' ' '{print $2}'); then
    echo "Error parsing redis_svc.sh file"
    log "In configdel, redis-server not found" "ERROR"
    exit 1
  fi

if [ "${CONFIG_NOW:0:1}" = "-" ]; then
    exit 0 # Already not set
  fi

log "Removing configuration entry ${CONFIG_NOW} from Redis service" "INFO"

if ! sed -i -e "s:${CONFIG_NOW} ::" ${LSWS_HOME}/lsns/bin/redis_svc.sh; then
    log "Error deleting configuration file" "ERROR"
    echo "Error deleting config file"
    exit 1
  fi

restart_all_svcs
  exit 0
}

function do_configupd()
{
  if [ ! -f "${LSWS_HOME}/lsns/bin/redis_svc.sh" ]; then
    exit 0 # Not installed, nothing to do
  fi

get_serverline
  if ! CONFIG_NOW=$(grep ${SERVER_LINE} ${LSWS_HOME}/lsns/bin/redis_svc.sh | awk -F ' ' '{print $2}'); then
    log "Error parsing redis_svc.sh file" "ERROR"
    echo "Error parsing redis_svc.sh file"
    exit 1
  fi

log "Setting Redis config file: ${1}" "INFO"

if [ "${CONFIG_NOW:0:1}" = "-" ]; then
    # Add it
    sed -i -e "s:${CONFIG_NOW}:${1} ${CONFIG_NOW}:" ${LSWS_HOME}/lsns/bin/redis_svc.sh
  else
    # Replace it
    sed -i -e "s:${CONFIG_NOW}:${1}:" ${LSWS_HOME}/lsns/bin/redis_svc.sh
  fi

# shellcheck disable=SC2181
  if [ "$?" != "0" ]; then
    log "Error adding/replacing config file" "ERROR"
    echo "Error adding/replacing config file"
    exit 1
  fi

restart_all_svcs
  exit 0
}

function restart_defaults_svcs()
{
  for FILE in /etc/systemd/system/multi-user\.target\.wants/user-redis*\.service ; do
    FILEONLY=$(basename "$FILE")
    USER=$(echo "$FILEONLY"|cut -d'@' -f2|sed -e "s/.service//")

if is_default_size "${USER}"; then
      systemctl restart "$FILEONLY"
    fi
  done
}

function delete_defaults_svcs()
{
  FILES=$(ls -1 /etc/systemd/system/multi-user\.target\.wants/user-redis*\.service)
  COUNT=$(wc -l <<< "${FILES}")
  FILE_NUM=0

while IFS= read -r FILE; do
    FILE_NUM=$((FILE_NUM + 1))

if [ "${STATUS_FILE}" != '' ]; then
      echo -e "${FILE_NUM}\n${COUNT}" > "${STATUS_FILE}"
    fi

FILEONLY=$(basename "$FILE")
    USER=$(echo "$FILEONLY"|cut -d'@' -f2|sed -e "s/.service//")

if is_default_size "${USER}"; then
      do_cleanupsvc_only "$USER"
    else
      log "Do not delete service for user: $USER not default size" "DEBUG"
    fi
  done <<< "${FILES}"
}

function do_defaultsizeset()
{
  ONLY=""

if (( $# > 1 )); then
    ONLY="1"
    log "ONLY set to $ONLY" "DEBUG"
  else
    log "ONLY not set" "DEBUG"
  fi

if [ -e "${DEFAULT_SIZE_FILENAME}" ]; then
    OLD_DEFAULT_SIZE=$(cat "${DEFAULT_SIZE_FILENAME}")
    log "Old default size: ${OLD_DEFAULT_SIZE}" "DEBUG"

if [ "${OLD_DEFAULT_SIZE}" = "${1}" ]; then

if [ "${ONLY}" != "1" ]; then
        echo "Default size set, but not changed"
        exit 0
      else
        return 0
      fi
    fi

if [ "${1}" = "0" ]; then
      log "Deleting default Redis configuration" "INFO"

if [ -e $DEFAULT_USERS_ACTIVATE_FILENAME ]; then
        rm $DEFAULT_USERS_ACTIVATE_FILENAME
      fi

rm "${DEFAULT_SIZE_FILENAME}"

if [ "${ONLY}" != "1" ]; then
        delete_defaults_svcs;
        exit 0
      else
        return 0
      fi
    fi
  fi

log "Setting default Redis configuration to ${1}MB" "INFO"

if [ "${1}" = "0" ]; then

if [ "${ONLY}" != "1" ]; then
      echo "Set default size to 0 and not set previously"
      exit 0
    else
      return 0
    fi
  fi

echo "${1}">"${DEFAULT_SIZE_FILENAME}"

if [ "${ONLY}" = "1" ]; then
    return 0
  fi

restart_defaults_svcs
  exit 0
}

function do_defaultsizeget()
{
  if [ -e "${DEFAULT_SIZE_FILENAME}" ]; then
    cat "${DEFAULT_SIZE_FILENAME}"
    exit 0
  fi

exit 1
}

function do_listdefaultusers()
{
  "${LIST_USERS}" | jq -r 'keys[]' | while IFS=''; read -r USER; do

if is_default_size "$USER"; then
      echo "$USER"
    fi
  done

exit 0
}

function do_pkg()
{
  if [ "$#" != "2" ]; then
    echo "You must specify a package name and nothing else"
    exit 1
  fi

log "do_pkg: $1 $2" "DEBUG"
  SIZE=$("${LSWS_HOME}/lsns/bin/lspkgctl" "-q" "list" "$2"|jq -r ".packages.\"$2\".size")

if [ "${SIZE}" = "" ]; then
    echo "You must specify a package with a defined default to use $1"
    exit 1
  fi

log "SIZE: $SIZE" "DEBUG"
  mapfile -t PACKAGE_UIDS < <("${LSWS_HOME}/lsns/bin/lspkgctl" "-q" "list" "$2"|jq -r ".packages.\"${2}\".uids[]")
  log "Did mapfile" "DEBUG"
  declare -A SVC_USERS

if ls /etc/systemd/system/multi-user.target.wants/user-redis* >/dev/null 2>&1; then

while read USER; do
      SVC_USERS[$USER]="1"
      log "SVC_USERS[$USER] set" "DEBUG"
    done <<< "$(ls -1 /etc/systemd/system/multi-user.target.wants/user-redis*|cut -d'@' -f 2|sed -e "s/.service//")"
  fi

declare -A HOME_DIRS
  declare -A UIDS_USER

while read LINE; do
    USER=$(echo "$LINE" | awk -F ':' '{print $1}')
    HOME_DIR=$(echo "$LINE" | awk -F ':' '{print $6}')
    HOME_DIRS[$USER]=$HOME_DIR
    USER_UID=$(echo "$LINE" | awk -F ':' '{print $3}')
    UIDS_USER[$USER_UID]="$USER"
    log "LINE: $LINE USER: $USER HOME_DIR: $HOME_DIR USER_UID: $USER_UID" "DEBUG"
  done <<< "$(cat /etc/passwd)"

if [[ "${1}" = "enablepkg" ]]; then
    ACTION="enablesvc"
  else
    ACTION="disable"
  fi

DID="0"

PACKAGE_NUM=0
  for PACKAGE_UID in "${PACKAGE_UIDS[@]}"; do

if [ "${STATUS_FILE}" != '' ]; then
      PACKAGE_NUM=$((PACKAGE_NUM + 1))
      echo -e "${PACKAGE_NUM}\n${#PACKAGE_UIDS[@]}" > "${STATUS_FILE}"
    fi

USER="${UIDS_USER[$PACKAGE_UID]}"
    log "Final pkg loop USER: $USER PACKAGE_UID: $PACKAGE_UID" "DEBUG"

if [[ "${SVC_USERS[$USER]}" == "" ]]; then
      log "No existing service for the user" "DEBUG"

if [[ "${1}" == "enablepkg" ]]; then
        get_dir_filenames

user_fn "${USER}" "${HOME_DIRS[$USER]}" "${SIZE}"
        DID="1"
      fi
    else
      log "Existing service for the user" "DEBUG"

if [[ "${1}" == "disablepkg" ]]; then
        user_fn "${USER}" "${HOME_DIRS[$USER]}" "${SIZE}"
        DID="1"
      fi
    fi
  done

if [ "${DID}" = "0" ]; then
    echo "No systems processed for ${1}"
    exit 1
  fi

exit 0
}

function do_enableunsized()
{
  MIN_UID=$("${LSWS_HOME}/lsns/bin/lsnsctl" get-min-uid -q)
  ACTION="enablesvc"
  touch $DEFAULT_USERS_ACTIVATE_FILENAME
  USERS=$("${LIST_USERS}" | jq -r 'keys[]')
  USER_COUNT=$(wc -l <<< "${USERS}")
  USER_NUM=0

while IFS= read -r USER; do
    USER_NUM=$((USER_NUM + 1))

if [ "${STATUS_FILE}" != "" ]; then
      echo -e "${USER_NUM}\n${USER_COUNT}" > "${STATUS_FILE}"
    fi

log "Potential user $USER #$USER_NUM" "DEBUG"

if is_default_size "$USER"; then
      get_homedir_filenames
      mk_user_files
      enable_svc
    else
      log "Not default size, do not enable" "DEBUG"
    fi
  done <<< "${USERS}"

exit 0
}

function is_default_enabled()
{
  if [ ! -e $DEFAULT_USERS_ACTIVATE_FILENAME ] || [ ! -e $DEFAULT_SIZE_FILENAME ]; then
    return 1
  fi

return 0
}

function do_disableunsized()
{
  if ! is_default_enabled; then
    echo "Unsized users not enabled"
    exit 1
  fi

rm $DEFAULT_USERS_ACTIVATE_FILENAME
  delete_defaults_svcs
  exit 0
}

function is_get_use_redis()
{
  if [ -e "${LSWS_HOME}/lsns/conf/use-valkey" ]; then
    return 1
  fi

return 0
}

function redis_install()
{
  if ! ./redis_svc_install.sh "$LSWS_HOME"; then
    log "Service installation failed" "ERROR"
    exit 1
  fi
}

function set_use_redis()
{
  if [ "$#" -lt 1 ]; then
    log "Checking if already redis" "DEBUG"

if ! is_get_use_redis; then
      log "Switching to redis from valkey" "INFO"
      rm "${LSWS_HOME}/lsns/conf/use-valkey"
      restart_all_svcs
    fi
  else
    log "Checking if already valkey" "DEBUG"

if is_get_use_redis; then
      log "Switching to valkey from redis" "INFO"
      touch "${LSWS_HOME}/lsns/conf/use-valkey"

if [ ! -e /usr/bin/valkey-server ]; then
        log "Do valkey installation" "INFO"
        redis_install
      fi

restart_all_svcs
    fi 
  fi

exit 0
}

# Begin mainline
LSWS_HOME="/usr/local/lsws"
LIST_USERS="/usr/local/psa/admin/plib/modules/litespeed/scripts/list-users"
STATUS_FILE=""

reset_LSWS_HOME_vars

cd "$(dirname "$0")"

if [ "$#" -lt 1 ]; then
  log "You must specify an action" "ERROR"
  exit 1
fi

if [ "${1:0:12}" = "STATUS_FILE=" ]; then
  STATUS_FILE="${1:12}"
  shift 1
fi

if [ "$#" -lt 1 ]; then
  log "You must specify an action" "ERROR"
  exit 1
fi

CMD_ARGS="$*"
log "Enter redis_user_action.sh: $CMD_ARGS" "DEBUG"

if [[ $1 == "list" ]] ; then
  ps -e -O ruser:64|grep "[r]edis_svc"|awk -F ' ' '{print $2}'
  exit 0
fi

if [[ $1 == "cleanup" ]] ; then

if (( $# != 2)); then
    echo "You must specify an action and a UID to do a cleanup"
    exit 255
  fi

do_cleanup "$2"
fi

if [[ $1 = "configdel" ]] ; then
  do_configdel
fi

if [[ $1 = "configupd" ]] ; then

if (( $# != 2)); then
    echo "You must specify an action and a config file to update the config"
    exit 255
  fi

if [ ! -f "${2}" ] ; then
    >&2 echo "Config file ${2} does not exist, can't be used"
    exit 1
  fi

do_configupd "$2"
fi

if [[ $1 = "defaultsizeset" ]] ; then

if (( $# != 2)); then
    echo "You must specify an action and a size to set the default size"
    exit 255
  fi

do_defaultsizeset "$2"
fi

if [[ $1 = "defaultsizeget" ]] ; then
  do_defaultsizeget
fi

if [[ $1 = "listdefaultusers" ]] ; then
  do_listdefaultusers
fi

if [ ! -f /etc/systemd/system/user-redis\@.service ] || [ ! -f "${LSWS_HOME}/lsns/bin/redis_svc.sh" ]; then
  log "Do redis installation" "INFO"
  redis_install
fi

if [[ $1 = "enableunsized" ]]; then

if (( $# > 1 )); then
    do_defaultsizeset "$2" "ONLY"
  elif [ ! -e $DEFAULT_SIZE_FILENAME ] ; then
    echo "You must specify a default size to enableunsized"
    exit 1
  fi

do_enableunsized
fi

if [[ $1 = "disableunsized" ]]; then
  do_disableunsized
fi

if [[ $1 = "getdefaultenabled" ]]; then
  is_default_enabled
  exit $?
fi

if [[ $1 = "getuseredis" ]]; then
  is_get_use_redis
  exit $?
fi

if [[ $1 = "getusevalkey" ]]; then

if is_get_use_redis; then
    exit 1
  fi

exit 0
fi

if [[ $1 = "setuseredis" ]]; then
  set_use_redis
fi

if [[ $1 = "setusevalkey" ]]; then
  set_use_redis "NO"
fi

if [[ $1 = *"pkg" ]] ; then
  do_pkg "$1" "$2"
fi

if is_default_size "$3"; then

if (( $# < 3 )); then
    echo "You must specify a user to enable/disable as well as the LSWS_HOME directory"
    exit 1
  fi

LSWS_HOME=$2
  reset_LSWS_HOME_vars
fi

if (( $# < 5 || ($# - 2) % 3 != 0 )); then
  echo "You must specify an action a litespeed home directory and one or more user homedir size triplets, there are $# params"
  exit 255
fi

LSWS_HOME=$2
reset_LSWS_HOME_vars
CONFDIR="${LSWS_HOME}/lsns/conf/"

if [ ! -d "$CONFDIR" ]; then
  mkdir -p "$CONFDIR"
  chmod 755 "${LSWS_HOME}/lsns"
  chmod 755 "${LSWS_HOME}/lsns/conf"
  BINDIR="${LSWS_HOME}/lsns/bin/"
  mkdir -p "$BINDIR"
  chmod 755 "${BINDIR}"
fi

CONF="${CONFDIR}/redis_size.conf"

if [ "$(whoami)" != 'root' ] ; then
  echo "Not root" 
  exit 255
fi

if [[ $1 == "" ]] ; then
  echo "action empty in redis user script"
  exit 255
fi

if [[ "$1" != "enable"* ]] && [[ "$1" != "disable"* ]]; then
  echo "Unknown action $1 while working on redis users"
  exit 255
fi

ACTION="${1}"
shift 2

while (( "$#" )); do
  user_fn "$1" "$2" "$3"
  shift 3
done

📁 Sid Gifari File Manager