st2ctl

#!/bin/bash
# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

COMPONENTS="st2actionrunner st2api st2stream st2auth st2garbagecollector st2notifier st2rulesengine st2sensorcontainer st2chatops st2timersengine st2workflowengine st2scheduler"
ST2_CONF="${ST2_CONF:-/etc/st2/st2.conf}"
SYSTEMD_RELOADED=""

# Ensure global environment is sourced if exists and if not executed in the context of Github Actions
# Does not happen consistently with all OSes we support.
[ -z "${GITHUB_ACTIONS}" ] && [ -r /etc/environment ] && source /etc/environment

# load in environment to allow override of COMPONENTS and ST2_CONF above
# Ubuntu/Debian
[ -r /etc/default/st2ctl ] && source /etc/default/st2ctl
# RHEL/CentOS/Rocky
[ -r /etc/sysconfig/st2ctl ] && source /etc/sysconfig/st2ctl


function print_usage() {
    echo "Usage: st2ctl {start, stop, restart, status}"
    echo
    echo "Usage: st2ctl {restart-component}"
    echo "positional arguments:"
    echo "  component           Name of the st2 service to restart."
    echo "                      ${COMPONENTS}"
    echo
    echo "Usage: st2ctl {reopen-log-files}"
    echo "positional arguments:"
    echo "  component           Name of the st2 service to reopen the log files for."
    echo "                      ${COMPONENTS}"
    echo
    echo "Usage: st2ctl {reload, clean}"
    echo "optional arguments:"
    echo "  --register-all                  Register all."
    echo "  --register-triggers             Register all triggers."
    echo "  --register-sensors              Register all sensors."
    echo "  --register-rules                Register all rules."
    echo "  --register-runners              Register all runners."
    echo "  --register-actions              Register all actions."
    echo "  --register-aliases              Register all aliases."
    echo "  --register-policies             Register all policies."
    echo "  --register-configs              Register all configuration files."
    echo "  --register-setup-virtualenvs    Create Python virtual environments for all the registered packs."
    echo "  --register-recreate-virtualenvs (Delete and re-)create Python virtual environments for all the registered packs."
    echo "  --register-fail-on-failure      Exit with non-zero if some resource registration fails. Deprecated. This is now a default behavior."
    echo "  --register-no-fail-on-failure   Don't exit with non-zero if some resource registration fails."
    echo "  --verbose                       Output additional debug and informational messages."
    echo ""
    echo "Most commands require elevated privileges."
}

function must_be_root() {
    if [ $(id -u) -ne 0 ]; then
        echo "Please run this command with root privileges"
        exit 1
    fi
}

# -- Detect whether running inside a Docker container --
function running_in_docker() {
    [ -f /.dockerenv ] && return 0
    return 1
}

# Tell the user to use Docker commands instead of st2ctl
function suggest_docker_usage() {
    echo -e "\e[31mError: “st2ctl $1” is not supported inside Docker.\e[0m"
    echo ""
    echo "Please manage StackStorm services with Docker commands, e.g.:"
    echo "  docker ps"
    echo "  docker-compose restart st2api"
    echo "  docker-compose logs -f st2stream"
    exit 1
}


function not_running_in_k8s() {
    if [ -n "$KUBERNETES_SERVICE_HOST" ]; then
        echo -e "\e[31mError: \"st2ctl status\" is not supported under Kubernetes, please use Kubernetes tools such as \"kubectl\" to view the StackStorm services in this cluster. \e[0m\n"
        exit 1
    fi
}

function validate_in_components() {
  COM=${1}

  if [ -z ${COM} ]; then
    echo -e "\e[31mError: Component is required! \e[0m\n"
    print_usage
    exit 1
  fi

  if [[ " ${COMPONENTS} " != *" ${COM} "* ]]; then
    echo -e "\e[31mError: Invalid component provided: ${COM} \e[0m\n"
    print_usage
    exit 1
  fi
}

function check_python_version() {
  PYTHON_VERSION=$(/opt/stackstorm/st2/bin/python --version 2>&1 | awk -F"[. ]" '{print $2}')
  if [ "${PYTHON_VERSION}" = "2" ]; then
    echo -e "\e[33mDeprecation warning: Support for python 2 will be removed in future StackStorm releases. Please ensure that all packs used are python 3 compatible. Your StackStorm installation may be upgraded from python 2 to python 3 in future platform releases. It is recommended to plan the manual migration to a python 3 native platform, e.g. Ubuntu 18.04 LTS or CentOS/RHEL 8. \e[0m\n"
  fi
}

function st2start() {
  for COM in ${COMPONENTS}; do
    service_manager ${COM} start
  done
  check_python_version
}

function st2stop() {
  for COM in ${COMPONENTS}; do
    service_manager ${COM} stop
  done
}

function service_manager() {
  local svcname=$1 action=$2
  if [ -d /run/systemd/system ]; then
    # systemd is running
    if [ -z $SYSTEMD_RELOADED ]; then
      #Reload systemd to regenerate socket files from st2.conf
      systemctl daemon-reload
      SYSTEMD_RELOADED="yes"
    fi
    systemctl $action $svcname
  elif [ $(cat /proc/1/comm) = init ] && (/sbin/initctl version 2>/dev/null | grep -q upstart) &&
          [ -f /etc/init/${svcname}.conf ]; then
    # init is running, and is upstart and service config is available
    # ! upstart running detection is a MUST, since upstart can be just
    # ! installed on a platform but not used (ex: docker container, centos).
    /sbin/initctl $action $svcname
  elif command -v service > /dev/null 2>&1; then
    service $svcname $action
  else
    echo -e "\e[31mError: Unknown service manager, we ONLY support systemd and upstart! \e[0m\n"
    exit 1
  fi
}

# Next candidate for removal
# after we implement native `service st2component reopen` (nginx example) for each component
function reopen_component_log_files() {
  COM=${1}

  PID=`ps axww | grep -v grep | grep -v st2ctl | grep -E "(${COM}\.wsgi)|(bin/${COM})|(hubot .*${COM})" | awk '{print $1}'`
  if [[ ! -z ${PID} ]]; then
    for p in ${PID}; do
      echo "Sending SIGUSR1 to ${COM} PID: ${p}"
      kill -USR1 ${p}
    done
  else
    echo "${COM} is not running"
    return 1
  fi
}

function register_content() {
  ALLOWED_REGISTER_FLAGS='--register-all --register-actions --register-aliases --register-runners --register-policies --register-rules --register-sensors --register-triggers --register-configs --register-setup-virtualenvs --register-recreate-virtualenvs --register-fail-on-failure --register-no-fail-on-failure --verbose'
  DEFAULT_REGISTER_FLAGS='--register-runners --register-actions --register-aliases --register-sensors --register-triggers --register-configs --register-rules'

  SUDO_FLAGS='--register-setup-virtualenvs  --register-recreate-virtualenvs'
  flags="${@}"

  if [ ! -z ${1} ]; then
    for flag in ${flags}; do
      if [[ " ${SUDO_FLAGS} " == *" $flag "* && "$(id -u)" != "0" ]]; then
        echo -e "\e[31mError: \"sudo\" required for: ${flag} \e[0m\n"
        exit 1
      fi
      if [[ " ${ALLOWED_REGISTER_FLAGS} " != *" $flag "* ]]; then # argument not allowed
        echo -e "\e[31mError: Invalid flag provided: ${flag} \e[0m\n"
        print_usage
        exit 1
      fi
    done
  fi

  if [ -z ${1} ]; then
    REGISTER_FLAGS=${DEFAULT_REGISTER_FLAGS}
  elif [ ${1} == '--verbose' ] && [ -z ${2} ]; then
    REGISTER_FLAGS="$DEFAULT_REGISTER_FLAGS ${1}"
  else
    REGISTER_FLAGS=${flags}
  fi

  echo "Registering content...[flags = --config-file ${ST2_CONF} ${REGISTER_FLAGS}]"
  st2-register-content --config-file ${ST2_CONF} ${REGISTER_FLAGS}
}

function clean_db() {
  echo "Dropping st2 Database..."
  /opt/stackstorm/st2/bin/st2-cleanup-db --config-file ${ST2_CONF}
}

function clean_logs() {
  echo "Cleaning st2 Logs..."
  rm -Rf /var/log/st2/*
}

function getpids() {
  echo "##### st2 components status #####"
  COMPONENTS=${COMPONENTS}

  for COM in ${COMPONENTS}; do
    PID=`ps axww | grep -v grep | grep -v st2ctl | grep -E "(${COM}\.wsgi)|(bin/${COM})|(hubot .*${COM})" | awk '{print $1}'`

    if [[ ! -z ${PID} ]]; then
      for p in ${PID}; do
        echo "${COM} PID: ${p}"
      done
    else
      echo "${COM} is not running."
    fi
  done
}

# If in Docker, refuse any of the VM‐style commands
if running_in_docker; then
    case "$1" in
        status)
            suggest_docker_usage "$1"
            ;;
    esac
fi


case ${1} in
  start)
    must_be_root
    st2start
    getpids
    ;;
  stop)
    must_be_root
    st2stop
    ;;
  restart)
    must_be_root
    st2stop
    sleep 1
    st2start
    getpids
    ;;
  restart-component)
    must_be_root
    validate_in_components ${2}
    service_manager ${2} restart
    check_python_version
    ;;
  reopen-log-files)
    must_be_root
    validate_in_components ${2}
    if reopen_component_log_files ${2}; then
      sleep 1
      getpids
    fi
    ;;
  reload)
    register_content ${@:2}
    exit_code=$?
    check_python_version
    getpids
    # Note: We want to preserve st2-register-content "fail on failure" behavior
    # and propagate the correct exit code and exit with non zero on failure
    exit ${exit_code}
    ;;
  clean)
    must_be_root
    echo "This will drop the database and delete all logs.  Are you sure [y/n]?"
    read verify
    if [[ "$verify" == "y" ]]; then
      st2stop
      clean_db
      clean_logs
      register_content ${@:2}
      st2start
      getpids
    else
      exit
    fi
    ;;
  status)
    not_running_in_k8s
    getpids
    ;;
  *)
    print_usage
    exit 1
    ;;
esac