dockerctl

#!/usr/bin/env bash

loadConfig() {
  configDir="${XDG_CONFIG_HOME:-$HOME/.config}/pkgmgr"
  configFile="$configDir/config.toml"

  createDefaultConfig() {
    mkdir -p "$(dirname "$configFile")"

    cat >"$configFile" <<'EOF'
# Compose directories (supports multiple paths)
composeDir = ["."]
scriptDir = ["."]
ignoreFiles = []

# map of compose file -> script + args
[postStartScripts]
# "diun.yml" = "webhooknotif.py --port 9999"
EOF
  }
  if [[ ! -f "$configFile" ]]; then
    createDefaultConfig
  fi

  declare -ga composeDir=()
  declare -ga scriptDir=()
  declare -ga ignoreFiles=()
  declare -gA postStartScripts=()

  parseTomlConfig() {
    expandVars() {
      local str="$1"
      if command -v envsubst >/dev/null 2>&1; then
        echo "$str" | envsubst
      else
        str="${str//\$HOME/$HOME}"
        str="${str//\$USER/$USER}"
        echo "$str"
      fi
    }

    parseArray() {
      local key="$1"
      local arrName="$2"
      local line

      line=$(sed -n "s/^[[:space:]]*${key}[[:space:]]*=[[:space:]]*\(.*\)/\1/p" "$configFile" | head -1)
      [[ -z "$line" ]] && return

      # Extract all double-quoted strings, remove quotes, expand vars
      local items=()
      while IFS= read -r quoted; do
        local item="${quoted#\"}"
        item="${item%\"}"
        item=$(expandVars "$item")
        items+=("$item")
      done < <(echo "$line" | grep -oE '"([^"]*)"')

      eval "${arrName}=(\"\${items[@]}\")"
    }

    parseArray "composeDir" "composeDir"
    parseArray "scriptDir" "scriptDir"
    parseArray "ignoreFiles" "ignoreFiles"

    local startLine endLine
    startLine=$(sed -n '/^[[:space:]]*\[postStartScripts\][[:space:]]*$/=' "$configFile" | head -1)
    if [[ -n "$startLine" ]]; then
      endLine=$(sed -n "$((startLine + 1)),\$ { /^[[:space:]]*\[/ { =; q } }" "$configFile")
      [[ -z "$endLine" ]] && endLine=$(wc -l <"$configFile")

      while IFS= read -r line; do
        [[ -z "$line" || "$line" =~ ^[[:space:]]*# ]] && continue
        if [[ "$line" =~ ^[[:space:]]*\"([^\"]+)\"[[:space:]]*=[[:space:]]*\"([^\"]*)\"[[:space:]]*$ ]]; then
          local key="${BASH_REMATCH[1]}"
          local val="${BASH_REMATCH[2]}"
          val=$(expandVars "$val")
          postStartScripts["$key"]="$val"
        fi
      done < <(sed -n "$((startLine + 1)),$((endLine - 1))p" "$configFile")
    fi
  }
  parseTomlConfig
}
loadConfig

debugMain() {
  echo "$configFile"
  echo "$configDir"
  declare -p composeDir
  declare -p scriptDir
  declare -p ignoreFiles
  declare -p postStartScripts
  echo
}

startSkipped=()
startFailed=()
startSuccess=()
startPostStartScriptSuccess=()
startPostStartScriptFailed=()

stopSkipped=()
stopFailed=()
stopSuccess=()
stopPostStartScriptSuccess=()
stopPostStartScriptFailed=()
stopPostStartScriptSkipped=()

restartFailed=()
restartSuccess=()

updateFailed=()
updateSuccess=()

isIgnored() {
  local file="$1"
  for ignore in "${ignoreFiles[@]}"; do
    if [[ "$(basename "$file")" == "$ignore" ]]; then
      return 0
    fi
  done
  return 1
}

isRunning() {
  local composeFile="$1"
  local projectName
  projectName=$(getProjectName "$composeFile")

  local containers
  containers=$(docker compose -f "$composeFile" -p "$projectName" ps -q)

  [[ -z "$containers" ]] && return 1

  local total=0
  local running=0

  for container in $containers; do
    ((total++))

    if [[ "$(docker inspect -f '{{.State.Running}}' "$container" 2>/dev/null)" == "true" ]]; then
      ((running++))
    fi
  done

  [[ $running -eq $total ]]
}

postStartScriptAction() {
  local action="$1"
  local composeFile="$2"

  local composeFileBasename
  composeFileBasename=$(basename "$composeFile")

  [[ -z "${postStartScripts[$composeFileBasename]}" ]] && return

  local -a postStartScript=()
  read -r -a postStartScript <<<"${postStartScripts[$composeFileBasename]}"
  local postStartScriptBase="${postStartScript[0]}"
  local -a postStartScriptArgs=("${postStartScript[@]:1}")

  local postStartScriptName=""
  local matches=()
  for scriptdir in "${scriptDir[@]}"; do
    [[ -z "$scriptdir" ]] && continue
    [[ ! -d "$scriptdir" ]] && continue

    while IFS= read -r match; do
      [[ -n "$match" ]] && matches+=("$match")
    done < <(
      find "$scriptdir" -maxdepth 2 -type f -name "$postStartScriptBase" -print
    )
  done

  case ${#matches[@]} in
  1)
    postStartScriptName="${matches[0]}"
    echo "   Found script at: $postStartScriptName"
    chmod +x "$postStartScriptName"

    if [[ "$action" == "start" ]]; then
      echo "   Running: $postStartScriptName ${postStartScriptArgs[*]}"
      nohup "$postStartScriptName" "${postStartScriptArgs[@]}" >/dev/null 2>&1 &
      pid=$!
      echo "$pid" >"/tmp/${postStartScriptBase}.pid"
      sleep 1

      if kill -0 "$pid" 2>/dev/null; then
        echo "   Successfully Started Script"
        startPostStartScriptSuccess+=("$postStartScriptName ${postStartScriptArgs[*]}")
      else
        echo "   Couldnot Start Script"
        startPostStartScriptFailed+=("$postStartScriptName ${postStartScriptArgs[*]}")
      fi
    elif [[ "$action" == "stop" ]]; then
      echo "   Stopping: $postStartScriptName ${postStartScriptArgs[*]}"

      pid_file="/tmp/${postStartScriptBase}.pid"

      if [[ -f "$pid_file" ]]; then
        pid=$(cat "$pid_file")
        if kill -9 "$pid" >/dev/null 2>&1; then
          rm -f "$pid_file"
          echo "   Successfully stopped Script"
          stopPostStartScriptSuccess+=("$postStartScriptName ${postStartScriptArgs[*]}")
        else
          echo "   Couldnot stop script"
          stopPostStartScriptFailed+=("$postStartScriptBase ${postStartScriptArgs[*]}")
          return 1
        fi
      else
        echo "   Script was already stopped"
        stopPostStartScriptSkipped+=("$postStartScriptBase ${postStartScriptArgs[*]}")
      fi
    else
      echo "Unknown Action for Script"
    fi
    ;;

  0)
    echo "   Warning: Could not find $postStartScriptBase within scriptDir. Skipping." >&2

    if [[ "$action" == "start" ]]; then
      startPostStartScriptFailed+=("$postStartScriptBase ${postStartScriptArgs[*]}")
    elif [[ "$action" == "stop" ]]; then
      stopPostStartScriptFailed+=("$postStartScriptBase ${postStartScriptArgs[*]}")
    else
      echo "Unknown Action for Script"
    fi
    return 1
    ;;

  *)
    echo "Error: multiple scripts found for '$postStartScriptBase':" >&2
    printf '  %s\n' "${matches[@]}" >&2

    if [[ "$action" == "start" ]]; then
      startPostStartScriptFailed+=("$postStartScriptBase ${postStartScriptArgs[*]}")
    elif [[ "$action" == "stop" ]]; then
      stopPostStartScriptFailed+=("$postStartScriptBase ${postStartScriptArgs[*]}")
    else
      echo "Unknown Action for Script"
    fi
    return 1
    ;;
  esac
}

startScript() {
  postStartScriptAction start "$1"
}

stopScript() {
  postStartScriptAction stop "$1"
}

findComposeFile() {
  local input="$1"
  local dir
  for dir in "${composeDir[@]:-.}"; do
    if [[ -n "$input" ]]; then
      if [[ "$input" =~ \.(yml|yaml)$ ]]; then
        find "$dir" -maxdepth 2 -type f -name "$input"
      else
        find "$dir" -maxdepth 2 -type f \( -name "$input.yml" -o -name "$input.yaml" \)
      fi
    else
      find "$dir" -maxdepth 2 -type f \( -name "*.yml" -o -name "*.yaml" \)
    fi
  done
}

resolveComposeFile() {
  local input="$1"
  local output

  if [[ -f "$input" ]]; then
    realpath "$input"
    return
  fi

  output=$(findComposeFile "$input" | head -n 1)

  if [[ -z "$output" ]]; then
    echo "Error: no specified yml/yaml file found" >&2
    return 1
  fi

  realpath "$output"
}

runComposeFiles() {
  local output

  if [[ -n "$1" ]]; then
    findComposeFile "$1" | head -n 1
  else
    findComposeFile
  fi
}

getProjectName() {
  basename "${1%.*}" | tr '.' '_'
}

runAction() {
  local action="$1"
  local composeFile="$2"

  local projectName
  projectName=$(getProjectName "$composeFile")

  echo "=> $action $composeFile"

  case "$action" in
  start)
    docker compose -f "$composeFile" -p "$projectName" up -d
    return $?
    ;;
  stop)
    docker compose -f "$composeFile" -p "$projectName" down
    return $?
    ;;
  update)
    docker compose -f "$composeFile" -p "$projectName" pull
    return $?
    ;;
  status)
    shift

    local followLogs=false
    local containerName=""

    while [[ $# -gt 0 ]]; do
      case "$1" in
      -f)
        followLogs=true
        ;;
      *)
        if [[ -n "$containerName" ]]; then
          echo "Error: status accepts only one container name"
          return 1
        fi
        containerName="$1"
        ;;
      esac
      shift
    done

    if [[ -z "$containerName" ]]; then
      echo "Error: container name required"
      return 1
    fi

    if $followLogs; then
      docker logs -f "$containerName"
    else
      docker logs "$containerName"
    fi
    return $?
    ;;
  esac
}

processFile() {
  local action="$1"
  local composeFile="$2"
  local projectName
  projectName=$(getProjectName "$composeFile")

  if isIgnored "$composeFile"; then
    echo "Skipping ignored file: $composeFile"
    return
  fi

  case "$action" in
  start)
    if isRunning "$composeFile"; then
      echo "$projectName is already Running!!!"
      startSkipped+=("$composeFile")
    else
      if runAction start "$composeFile"; then
        startSuccess+=("$composeFile")
        startScript "$composeFile"
      else
        startFailed+=("$composeFile")
      fi
    fi
    ;;

  stop)
    if isRunning "$composeFile"; then
      if runAction stop "$composeFile"; then
        stopSuccess+=("$composeFile")
        stopScript "$composeFile"
      else
        stopFailed+=("$composeFile")
      fi
    else
      echo "$projectName is already Stopped!!!"
      stopSkipped+=("$composeFile")
    fi
    ;;

  restart)
    if isRunning "$composeFile"; then
      if runAction stop "$composeFile"; then
        stopSuccess+=("$composeFile")
        if ! stopScript "$composeFile"; then
          restartFailed+=("$composeFile")
          return 1
        fi
      else
        stopFailed+=("$composeFile")
        restartFailed+=("$composeFile")
        return 1
      fi
    else
      echo "$projectName is already Stopped!!!"
      stopSkipped+=("$composeFile")
    fi
    if isRunning "$composeFile"; then
      echo "$projectName is already Running!!!"
      startSkipped+=("$composeFile")
    else
      if runAction start "$composeFile"; then
        startSuccess+=("$composeFile")
        startScript "$composeFile"
      else
        startFailed+=("$composeFile")
        restartFailed+=("$composeFile")
        return 1
      fi
    fi

    if isRunning "$composeFile"; then
      restartSuccess+=("$composeFile")
    else
      restartFailed+=("$composeFile")
    fi
    ;;

  update)
    if runAction update "$composeFile"; then
      updateSuccess+=("$composeFile")
      if isRunning "$composeFile"; then
        if runAction stop "$composeFile"; then
          stopSuccess+=("$composeFile")
          if ! stopScript "$composeFile"; then
            restartFailed+=("$composeFile")
            return 1
          fi
        else
          stopFailed+=("$composeFile")
          restartFailed+=("$composeFile")
          return 1
        fi
      else
        echo "$projectName is already Stopped!!!"
        stopSkipped+=("$composeFile")
      fi
      if isRunning "$composeFile"; then
        echo "$projectName is already Running!!!"
        startSkipped+=("$composeFile")
      else
        if runAction start "$composeFile"; then
          startSuccess+=("$composeFile")
          startScript "$composeFile"
        else
          startFailed+=("$composeFile")
          restartFailed+=("$composeFile")
          return 1
        fi
      fi
    else
      updateFailed+=("$composeFile")
      return 1
    fi

    if isRunning "$composeFile"; then
      restartSuccess+=("$composeFile")
    else
      restartFailed+=("$composeFile")
    fi
    ;;
  esac
}

runMain() {
  local showIgnored=false
  local action="$1"
  shift

  if [ $# -eq 0 ]; then
    showIgnored=true
    while read -r composeFile; do
      echo
      processFile "$action" "$composeFile"
      echo
    done < <(runComposeFiles)
  else
    for input in "$@"; do
      for ignored in "${ignoreFiles[@]}"; do
        if [[ "$input" == "$ignored" ]]; then
          showIgnored=true
          ignoredFile+=("$input")
          break 2
        fi
      done
      while read -r composeFile; do
        echo
        processFile "$action" "$composeFile"
        echo
      done < <(runComposeFiles "$input")
    done
  fi

  echo -e "\n===== SUMMARY ====="
  if $showIgnored; then
    ((${#ignoredFile[@]})) && echo -e "\nIgnored:" && printf ' \033[1mℹ\033[0m %s\n' "${ignoredFile[@]}"
  fi

  case "$action" in
  start)
    ((${#startSkipped[@]})) && echo -e "\nSkipped:" && printf ' \033[1mℹ\033[0m Skipped (already running) %s\n' "${startSkipped[@]}"
    ((${#startSuccess[@]})) && echo -e "\nStarted:" && printf '✔ Successfully started %s\n' "${startSuccess[@]}"
    ((${#startFailed[@]})) && echo -e "\nFailed to Start:" && printf '✘ Failed to Start %s\n' "${startFailed[@]}"
    ((${#startPostStartScriptSuccess[@]})) && echo -e "\nStarted Scripts:" && printf '✔ Successfully Started Script %s\n' "${startPostStartScriptSuccess[@]}"
    ((${#startPostStartScriptFailed[@]})) && echo -e "\nFailed Script Starts:" && printf ' ✘ %s\n' "${startPostStartScriptFailed[@]}"
    ;;
  stop)
    ((${#stopSkipped[@]})) && echo -e "\nSkipped:" && printf ' \033[1mℹ\033[0m Skipped (already stopped) %s\n' "${stopSkipped[@]}"
    ((${#stopSuccess[@]})) && echo -e "\nStopped:" && printf '✔ Successfully stopped %s\n' "${stopSuccess[@]}"
    ((${#stopFailed[@]})) && echo -e "\nFailed to Stop:" && printf '✘ Failed to stop %s\n' "${stopFailed[@]}"
    ((${#stopPostStartScriptSuccess[@]})) && echo -e "\nStopped Scripts:" && printf '✔ Successfully Stopped Script %s\n' "${stopPostStartScriptSuccess[@]}"
    ((${#stopPostStartScriptFailed[@]})) && echo -e "\nFailed Script Stops:" && printf ' ✘ %s\n' "${stopPostStartScriptFailed[@]}"
    ((${#stopPostStartScriptSkipped[@]})) && echo -e "\nSkipped Script Stops:" && printf ' \033[1mℹ\033[0m  %s\n' "${stopPostStartScriptSkipped[@]}"
    ;;
  restart)
    ((${#restartSuccess[@]})) && echo -e "\nRestarted:" && printf '✔ Successfully Restarted %s\n' "${restartSuccess[@]}"
    ((${#restartFailed[@]})) && echo -e "\nFailed to Restart:" && printf ' ✘ Failed to Restart %s\n' "${restartFailed[@]}"
    ;;
  update)
    ((${#updateSuccess[@]})) && echo -e "\nUpdated:" && printf '✔ Successfully Updated %s\n' "${updateSuccess[@]}"
    ((${#updateFailed[@]})) && echo -e "\nFailed to Update:" && printf '✘ Failed to Update %s\n' "${updateFailed[@]}"
    ((${#restartSuccess[@]})) && echo -e "\nRestarted:" && printf '✔ Successfully Restarted %s\n' "${restartSuccess[@]}"
    ((${#restartFailed[@]})) && echo -e "\nFailed to Restart:" && printf ' ✘ Failed to Restart %s\n' "${restartFailed[@]}"
    ;;
  esac

  if ((${#startFailed[@]})) || ((${#stopFailed[@]})) || ((${#updateFailed[@]})) || ((${#restartFailed[@]})) || ((${#startPostStartScriptFailed[@]})) || ((${#stopPostStartScriptFailed[@]})); then
    exit 2
  else
    exit 0
  fi
}

helpMenu() {
  echo -e "$(basename "$0"): A script to start, stop, restart and update docker containers and images through their compose files and view their logs."
  echo
  echo -e "Example usage:"
  echo -e "  $(basename "$0") args path/to/docker-compose/.yml/file"
  echo -e "  $(basename "$0") args containerName"
  echo -e
  echo -e "   Args         Subargs            Description"
  echo -e "   start                           starts the specified compose file"
  echo -e "   stop                            stops the specified compose file"
  echo -e "   restart                         restarts the specified compose file"
  echo -e "   update                          updates all the images of the specified compose file. For individual images use 'docker pull imagename:tag'"
  echo -e "   status                          shows the logs of the specified container. Only accepts one container as arguement."
  echo -e "               -f                  Used with status arg to follow the container logs."
  echo -e "   --help/-h                       print the help menu"
  echo
  echo -e "NOTE: Needs docker compose .yml files either in current dir or provide the path to docker-compose .yml file as in example"
  echo -e "examples:"
  echo -e "  $(basename "$0") start vaultwarden"
  echo -e "  $(basename "$0") start /home/${USER}/vaultwarden.yml"
  echo
  echo -e "status examples:"
  echo -e "  $(basename "$0") status containerName"
  echo -e "  $(basename "$0") status containerName -f"
  echo
  echo -e "NOTE: You can use multiple compose.yml file separated by space (except for status arg. It shows log of one container only)"
  echo -e "  $(basename "$0") args composefile1 composefile2 composefile3"
}

case "$1" in
"start" | "stop" | "restart" | "update") runMain "$@" ;;
"status") runAction "$@" ;;
"--debug") loadConfig "$@"; debugMain;;
--help | -h) helpMenu ;;
*) helpMenu ;;
esac