psu/psu

#!/usr/bin/env bash
#
# Deploy/update/undeploy Docker stacks in a Portainer instance.

############################
# Print an error to stderr #
# Globals:                 #
#   None                   #
# Arguments:               #
#   $1 Error message       #
# Returns:                 #
#   None                   #
############################
err() {
  local error_message=$@
  echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')]: $error_message" >&2
}

#######################################
# Check a parameter has been provided #
# Globals:                            #
#   None                              #
# Arguments:                          #
#   $1 Argument value                 #
#   $2 Argument name                  #
#   $3 Argument envvar                #
#   $4 Argument flag                  #
# Returns:                            #
#   None                              #
#######################################
check_argument () {
  local argument_value=$1
  local argument_name=$2
  local argument_envvar=$3
  local argument_flag=$4
  if [ -z "$argument_value" ]; then
    err "Error: Missing argument \"$argument_name\"."
    err "Try setting \"$argument_envvar\" environment variable or using the \"-$argument_flag\" flag."
    exit 1
  fi
}

###########################################
# Checks for error exit codes from httpie #
# Globals:                                #
#   None                                  #
# Arguments:                              #
#   $1 Httpie exit code                   #
#   $2 Response returned by Portainer API #
# Returns:                                #
#   None                                  #
###########################################
check_for_errors () {
  local exit_code=$1
  local response=$2
  if [ $exit_code -ne 0 ]; then
    case $exit_code in
        2) err 'Request timed out!' ;;
        3) err 'Unexpected HTTP 3xx Redirection!' ;;
        4) err 'HTTP 4xx Client Error!' && err $response ;;
        5) err 'HTTP 5xx Server Error!' && err $response ;;
        6) err 'Exceeded --max-redirects=<n> redirects!' ;;
        *) err 'Unholy Error!' ;;
    esac
    exit 1
  fi
}

###########################################
# Print message if verbose mode is active #
# Globals:                                #
#   VERBOSE_MODE                          #
# Arguments:                              #
#   $1 Message                            #
# Returns:                                #
#   None                                  #
###########################################
echo_verbose () {
  local message=$1
  if [ $VERBOSE_MODE == "true" ]; then
    echo $message
  fi
}

#########################################
# Print message if debug mode is active #
# Globals:                              #
#   DEBUG_MODE                          #
# Arguments:                            #
#   $1 Message                          #
# Returns:                              #
#   None                                #
#########################################
echo_debug () {
  local message=$1
  if [ $DEBUG_MODE == "true" ]; then
    echo $message
  fi
}

##########################
# Create/update a stack  #
# Globals:               #
#   DOCKER_COMPOSE_FILE  #
#   PORTAINER_STACK_NAME #
#   PORTAINER_URL        #
#   HTTPIE_VERIFY_SSL    #
#   PORTAINER_ENDPOINT   #
#   AUTH_TOKEN           #
# Arguments:             #
#   None                 #
# Returns:               #
#   None                 #
##########################
deploy () {
  # Read docker-compose file content
  STACK_YAML_CONTENT=$(cat "$DOCKER_COMPOSE_FILE")

  # Remove carriage returns
  STACK_YAML_CONTENT="${STACK_YAML_CONTENT//$'\r'/''}"

  # Escape double quotes
  STACK_YAML_CONTENT="${STACK_YAML_CONTENT//$'"'/'\"'}"

  # Escape newlines
  STACK_YAML_CONTENT="${STACK_YAML_CONTENT//$'\n'/'\n'}"

  # If the stack does not exist
  if [ -z "$STACK" ]; then
    echo_verbose "Stack $PORTAINER_STACK_NAME does not exist."

    # Get Docker info
    echo_verbose "Getting Docker info..."
    DOCKER_INFO=$(http \
      --check-status \
      --ignore-stdin \
      --verify=$HTTPIE_VERIFY_SSL \
      "$PORTAINER_URL/api/endpoints/$PORTAINER_ENDPOINT/docker/info" \
      "Authorization: Bearer $AUTH_TOKEN")
    check_for_errors $? "$DOCKER_INFO"
    echo_debug "Docker info -> $DOCKER_INFO"

    # Get Docker swarm ID
    echo_verbose "Getting swarm cluster (if any)..."
    SWARM_ID=$(echo $DOCKER_INFO | jq -r ".Swarm.Cluster.ID // empty")
    echo_debug "Swarm ID -> $SWARM_ID"
    
    # If there is no swarm ID
    if [ -z "$SWARM_ID" ];then
      echo_verbose "Swarm cluster not found."

      echo_verbose "Preparing stack JSON..."
      DATA_PREFIX="{\"Name\":\"$PORTAINER_STACK_NAME\",\"StackFileContent\":\""
      DATA_SUFFIX="\"}"
      echo "$DATA_PREFIX$STACK_YAML_CONTENT$DATA_SUFFIX" > json.tmp
      echo_debug "Stack JSON -> $DATA_PREFIX$STACK_YAML_CONTENT$DATA_SUFFIX"

      # Create stack for single Docker instance
      echo_verbose "Creating stack $PORTAINER_STACK_NAME..."
      CREATE=$(http \
        --check-status \
        --ignore-stdin \
        --verify=$HTTPIE_VERIFY_SSL \
        --timeout=300 \
        "$PORTAINER_URL/api/stacks" \
        "Authorization: Bearer $AUTH_TOKEN" \
        type==2 \
        method==string \
        endpointId==$PORTAINER_ENDPOINT \
        @json.tmp)
      echo_debug "Create action response -> $CREATE"
    else
      echo_verbose "Swarm cluster found."

      echo_verbose "Preparing stack JSON..."
      DATA_PREFIX="{\"Name\":\"$PORTAINER_STACK_NAME\",\"SwarmID\":\"$SWARM_ID\",\"StackFileContent\":\""
      DATA_SUFFIX="\"}"
      echo "$DATA_PREFIX$STACK_YAML_CONTENT$DATA_SUFFIX" > json.tmp
      echo_debug "Stack JSON -> $DATA_PREFIX$STACK_YAML_CONTENT$DATA_SUFFIX"

      # Create stack for Docker swarm
      echo_verbose "Creating stack $PORTAINER_STACK_NAME..."
      CREATE=$(http \
        --check-status \
        --ignore-stdin \
        --verify=$HTTPIE_VERIFY_SSL \
        --timeout=300 \
        "$PORTAINER_URL/api/stacks" \
        "Authorization: Bearer $AUTH_TOKEN" \
        type==1 \
        method==string \
        endpointId==$PORTAINER_ENDPOINT \
        @json.tmp)
      echo_debug "Create action response -> $CREATE"
    fi
    check_for_errors $? "$CREATE"

    rm json.tmp
  else
    if [ $STRICT_MODE == "true" ]; then
      err "Error: Stack $PORTAINER_STACK_NAME already exists."
      exit 1
    fi
    echo_verbose "Stack $PORTAINER_STACK_NAME exists."

    echo_verbose "Preparing stack JSON..."
    STACK_ID="$(echo "$STACK" | jq -j ".Id")"
    STACK_ENV_VARS="$(echo -n "$STACK"| jq ".Env" -jc)"
    DATA_PREFIX="{\"Id\":\"$STACK_ID\",\"StackFileContent\":\""
    DATA_SUFFIX="\",\"Env\":"$STACK_ENV_VARS",\"Prune\":$PORTAINER_PRUNE}"
    echo "$DATA_PREFIX$STACK_YAML_CONTENT$DATA_SUFFIX" > json.tmp
    echo_debug "Stack JSON -> $DATA_PREFIX$STACK_YAML_CONTENT$DATA_SUFFIX"
    
    # Update stack
    echo_verbose "Updating stack $PORTAINER_STACK_NAME..."
    UPDATE=$(http \
      --check-status \
      --ignore-stdin \
      --verify=$HTTPIE_VERIFY_SSL \
      --timeout=300 \
      PUT "$PORTAINER_URL/api/stacks/$STACK_ID" \
      "Authorization: Bearer $AUTH_TOKEN" \
      endpointId==$PORTAINER_ENDPOINT \
      @json.tmp)
    echo_debug "Update action response -> $UPDATE"
    check_for_errors $? "$UPDATE"
    
    rm json.tmp
  fi
}

##########################
# Remove a stack         #
# Globals:               #
#   PORTAINER_STACK_NAME #
#   PORTAINER_URL        #
#   HTTPIE_VERIFY_SSL    #
#   AUTH_TOKEN           #
# Arguments:             #
#   None                 #
# Returns:               #
#   None                 #
##########################
undeploy () {
  if [ -z "$STACK" ]; then
    if [ $STRICT_MODE == "true" ]; then
      err "Error: Stack $PORTAINER_STACK_NAME does not exist."
      exit 1
    else
      echo_verbose "Stack $PORTAINER_STACK_NAME does not exist. No need to undeploy it."
      exit 0
    fi
  fi
  echo_verbose "Stack $PORTAINER_STACK_NAME exists."

  STACK_ID="$(echo "$STACK" | jq -j ".Id")"
  echo_debug "Stack ID -> $STACK_ID"

  echo_verbose "Deleting stack $PORTAINER_STACK_NAME..."
  DELETE=$(http \
    --ignore-stdin \
    --verify=$HTTPIE_VERIFY_SSL \
    DELETE "$PORTAINER_URL/api/stacks/$STACK_ID" \
    "Authorization: Bearer $AUTH_TOKEN")
  echo_debug "Delete action response -> $UPDATE"
  check_for_errors $? "$DELETE"
}

# Set arguments through envvars
ACTION=${ACTION}
PORTAINER_USER=${PORTAINER_USER}
PORTAINER_PASSWORD=${PORTAINER_PASSWORD}
PORTAINER_URL=${PORTAINER_URL}
PORTAINER_STACK_NAME=${PORTAINER_STACK_NAME}
DOCKER_COMPOSE_FILE=${DOCKER_COMPOSE_FILE}
PORTAINER_ENDPOINT=${PORTAINER_ENDPOINT:-"1"}
PORTAINER_PRUNE=${PORTAINER_PRUNE:-"false"}
HTTPIE_VERIFY_SSL=${HTTPIE_VERIFY_SSL:-"yes"}
VERBOSE_MODE=${VERBOSE_MODE:-"false"}
DEBUG_MODE=${DEBUG_MODE:-"false"}
STRICT_MODE=${STRICT_MODE:-"false"}

# Set arguments through flags (overwrite envvars)
while getopts a:u:p:l:n:c:e:rsvdt option; do
  case "${option}" in
    a) ACTION=${OPTARG} ;;
    u) PORTAINER_USER=${OPTARG} ;;
    p) PORTAINER_PASSWORD=${OPTARG} ;;
    l) PORTAINER_URL=${OPTARG} ;;
    n) PORTAINER_STACK_NAME=${OPTARG} ;;
    c) DOCKER_COMPOSE_FILE=${OPTARG} ;;
    e) PORTAINER_ENDPOINT=${OPTARG} ;;
    r) PORTAINER_PRUNE="true" ;;
    s) HTTPIE_VERIFY_SSL="no" ;;
    v) VERBOSE_MODE="true" ;;
    d) DEBUG_MODE="true" ;;
    t) STRICT_MODE="true" ;;
  esac
done

# Print config (only if debug mode is active)
echo_debug "ACTION -> $ACTION"
echo_debug "PORTAINER_USER -> $PORTAINER_USER"
echo_debug "PORTAINER_PASSWORD -> $PORTAINER_PASSWORD"
echo_debug "PORTAINER_URL -> $PORTAINER_URL"
echo_debug "PORTAINER_STACK_NAME -> $PORTAINER_STACK_NAME"
echo_debug "DOCKER_COMPOSE_FILE -> $DOCKER_COMPOSE_FILE"
echo_debug "PORTAINER_ENDPOINT -> $PORTAINER_ENDPOINT"
echo_debug "PORTAINER_PRUNE -> $PORTAINER_PRUNE"
echo_debug "HTTPIE_VERIFY_SSL -> $HTTPIE_VERIFY_SSL"
echo_debug "VERBOSE_MODE -> $VERBOSE_MODE"
echo_debug "DEBUG_MODE -> $DEBUG_MODE"

# Check required arguments have been provided
check_argument "$ACTION" "action" "ACTION" "a"
check_argument "$PORTAINER_USER" "portainer user" "PORTAINER_USER" "u"
check_argument "$PORTAINER_PASSWORD" "portainer password" "PORTAINER_PASSWORD" "p"
check_argument "$PORTAINER_URL" "portainer url" "PORTAINER_URL" "l"
check_argument "$PORTAINER_STACK_NAME" "portainer stack name" "PORTAINER_STACK_NAME" "n"
if [ $ACTION == "deploy" ]; then
  check_argument "$DOCKER_COMPOSE_FILE" "docker compose file" "DOCKER_COMPOSE_FILE" "c"
fi

# Get Portainer auth token. Will be used on every API request.
echo_verbose "Getting auth token..."
AUTH_TOKEN=$(http \
  --check-status \
  --ignore-stdin \
  --verify=$HTTPIE_VERIFY_SSL \
  $PORTAINER_URL/api/auth \
  username=$PORTAINER_USER \
  password=$PORTAINER_PASSWORD)
echo_debug "Get auth token response -> $AUTH_TOKEN"
check_for_errors $? "$AUTH_TOKEN"
AUTH_TOKEN=$(echo $AUTH_TOKEN | jq -r .jwt)
echo_debug "Auth token -> $AUTH_TOKEN"

# Get list of all stacks
echo_verbose "Getting stack $PORTAINER_STACK_NAME..."
STACKS=$(http \
  --check-status \
  --ignore-stdin \
  --verify=$HTTPIE_VERIFY_SSL \
  "$PORTAINER_URL/api/stacks" \
  "Authorization: Bearer $AUTH_TOKEN")
echo_debug "Get stacks response -> $STACKS"
check_for_errors $? "$STACKS"

# Get desired stack from stacks list by it's name
STACK=$(echo "$STACKS" \
  | jq --arg PORTAINER_STACK_NAME "$PORTAINER_STACK_NAME" -jc '.[] | select(.Name == $PORTAINER_STACK_NAME)')
echo_debug "Stack -> $STACK"

if [ $ACTION == "deploy" ]; then
  deploy
  exit 0
fi

if [ $ACTION == "undeploy" ]; then
  undeploy
  exit 0
fi

err "Error: Unknown action \"$ACTION\"."
exit 1