shedc

#!/bin/sh

myname="${0##*/}"
mypid="${$}"

# OldWorkDir=$PWD

# cd "${XDG_CONFIG_HOME}/shed/services"

# result of: id -u $USER
# cuz $UID is not POSIX ¯\_(ツ)_/¯
UserID=$(id -u "$USER")

# dir of the pid files for the current session
GUISessionDir=/run/user/${UserID}/GUISession${GUI_SESSION_PID}

# directory where we are loading the user services to start from
ServicesDir="${XDG_CONFIG_HOME:-~/.config}"/shed/services

# unix command line compatible booleans

# Type: int
# value: 0
_true=0
# Type: int
# value: 1
_false=1

# read the contents of the pid file, cat but more "elegant"

# Usage: read_file file [prefix]
#   [prefix]: if provided the characters here will be used a prefix when
#   printing the contents of the file.
#
# Return: string '[prefix]line'
read_file() {
  if [ $# -gt 1 ]; then
    prefix=$2
  else
    prefix=""
  fi
  while read -r FileLine
  do
    printf '%s%s\n' "$prefix" "$FileLine"
  done < "$1"
}

# Usage: progspinner prefix [time]
#   prefix: the string the will appear before the progress spinner
#   time: optional, amount of time the spinner will be spinning for, by default
#         2 seconds
#
# Return: string
progspinner() {
  count=0
  spinSymbol=0
  progspinner=0
  progspinnerPrefix="$1"
  if [ -z "$2" ]; then
    totaltime=2
  else
    totaltime="$2"
  fi
  steptime=$(awk -v tt="$totaltime" 'BEGIN {printf "%.2f", tt/20}')

  while [ "$count" -le 20 ]; do
    case "$spinSymbol" in
      0) spin="-" ;;
      1) spin="\\" ;;
      2) spin="|" ;;
      3) spin="/" ;;
    esac
    printf ' %s%3d%s\r' "$progspinnerPrefix $spin   [" "$progspinner" "%]"
    sleep "$steptime"
    count=$(( count + 1 ))
    spinSymbol=$(( spinSymbol + 1 ))
    progspinner=$(( progspinner + 5 ))
    [ "$spinSymbol" -gt 3 ] && spinSymbol=0
  done
  printf '  %s%3d%s\r' "$progspinnerPrefix    [" "100" "%]"
  sleep 0.1
  printf '\n'
}

# Usage: pretty_print file
#   uses awk to print the contents of the passed file to the terminal.
#
# Return: string
pretty_print() {
    awk '
      {
        if (NR==1) {
          printf " ┌"; for(c=0;c<65;c++) printf"─"; printf "┐\n" ;
          printf " │ %63s │\n", $0 ;
          printf " ├"; for(c=0;c<32;c++) printf"─"; printf "┬";
          for(c=0;c<22;c++) printf"─"; printf "┬";
          for(c=0;c<9;c++) printf"─"; printf "┤\n" ;
          printf " │ %30s │ %20s │ %7s │\n", "service           ", "date        ", "status ";
          printf " ├"; for(c=0;c<32;c++) printf"─"; printf "┼";
          for(c=0;c<22;c++) printf"─"; printf "┼";
          for(c=0;c<9;c++) printf"─"; printf "┤\n" ;
          }
        else { printf " │ %30s │ %20s │ %7s │\n", $1, $2, $3 };
      }
      END { printf " └"; for(c=0;c<32;c++) printf"─"; printf "┴";
          for(c=0;c<22;c++) printf"─"; printf "┴";
          for(c=0;c<9;c++) printf"─"; printf "┘\n" ;}
      ' "$1"

}

# Usage: read_reply
#   it will read the contents of the reply file and print them to the terminal
#   with either the pretty_print or a printf with a prefix from read_file.
#
# Return: string from called function
read_reply() {
  progspinner "retrieving status:"
  if [ -z "$PrettyPrint" ]; then
    read_file "${GUISessionDir}/reply" "  "
  else
    pretty_print "${GUISessionDir}/reply"
  fi
}

# Usage: read_pipe pipe_file
#   reads the contents of the passed named pipe, will time out in 10 seconds if
#   nothing is written to the pipe.
#
#   this is rather in this implementation and needs more work.
read_pipe() {
  # all messages read will be stored here
  varfile="/tmp/${myname}_${mypid}"
  # pipe we read from
  pipe="${1}"
  # we wait max 10 seconds without reply
  waittime=10
  # we cycle twice per second
  cycles=$((waittime * 2))

  cont=0
  while [ "$cont" = 0 ]; do
    : > "$varfile"
    var=""
    cat "$pipe" > "$varfile" &
    catpid=$!
    var=$(cat "$varfile")
    if [ -z "$var" ]; then
      count=0
      while [ "$count" -le "$cycles" ] && [ -z "$var" ]; do
        sleep 0.5
        var=$(cat "$varfile")
        count=$((count + 1))
      done
      kill $catpid 2>/dev/null
    fi
    if [ -z "$var" ]; then
      # echo "timeout: no message received"
      cont=1
    else
      printf '%s\n' "$var"
    fi
  done

  rm "$varfile"
}

# Usage: readserviceprop "PROPERTY" file
# Return: string containing the value of the PROPERTY key from the passed file
readserviceprop(){
  # Setting 'IFS' tells 'read' where to split the string.
  while IFS='=' read -r key val; do
    # Skip over lines containing comments.
    # (Lines starting with '#').
    [ "${key##\#*}" ] || continue

    # '$key' stores the key.
    # '$val' stores the value.
    if [ "$key" = "$1" ]; then
      printf '%s\n' "$val"
    fi
  done < "$2"
}

# Usage: procstat all | <service name>
#   all: status for all services
#   <service name>: status of service
#
# Return: string containing status
procstat() {
  if [ -z "$1" ] || [ "all" = "$1" ]; then
    if [ "$PrettyPrint" = 1 ]; then
      # default pid length
      pw=6
      # use per system pid length
      os_type=$(uname -s)
      case "${os_type}" in
        Linux)
          pw=$(wc -c /proc/sys/kernel/pid_max | awk '{ print $1 }')
          ;;
        NetBSD)
          pidmax=30000
          pw=$(printf '%s\n' "$pidmax" | wc -c)
          ;;
        OpenBSD|FreeBSD|*BSD)
          pidmax=99999
          pw=$(printf '%s\n' "$pidmax" | wc -c)
          ;;
      esac
    fi
    for i in "${ServicesDir}"/* ; do
      ServiceFileName="${i##*/}"
        s_name=$(readserviceprop "NAME" "$i")
        s_exec=$(readserviceprop "EXEC" "$i")
        if [ -f "${GUISessionDir}/${s_name}.pid" ]; then
          s_pid=$(read_file "${GUISessionDir}/${s_name}.pid")
          if kill -0 "$s_pid" 2>/dev/null; then
            s_state="+"
          else
            s_state="?"
          fi
        else
            s_state="-"
        fi
        if [ "$PrettyPrint" = 1 ]; then
          printf ' [ %s ] %30s %*s %s\n' "$s_state" "$s_name" "$pw" "$s_pid" "$s_exec"
        else
          printf ' [ %s ] %s\n' "$s_state" "$s_name"
        fi
    done
  else
    for i in "${ServicesDir}"/* ; do
      ServiceFileName="${i##*/}"
      if [ "$ServiceFileName" = "$1" ]; then
        s_name=$(readserviceprop "NAME" "$i")
        if [ -f "${GUISessionDir}/${s_name}.pid" ]; then
          s_pid=$(read_file "${GUISessionDir}/${s_name}.pid")
          if kill -0 "$s_pid" 2>/dev/null; then
            s_state="running with pid: ${s_pid}"
          else
            s_state="was started"
          fi
        else
            s_state="not running"
        fi
        printf '  %s\tstatus: %s\n' "$s_name" "$s_state"
      fi
    done
  fi
}

# Usage: hupprocs all | <service name>
#   all: hup to all services
#   <service name>: hup service
#
# Return: string
hupprocs() {
  if [ -z "$1" ] || [ "all" = "$1" ]; then
    for i in "${GUISessionDir}"/*.pid ; do
      s_pid=$(read_file "$i")
      # s_name=$(ps -p "$s_pid" -o comm=)
      s_name="${i##*/}"
      for s in "${ServicesDir}"/* ; do
        ServiceFileName="${s##*/}"
        i_name=$(readserviceprop "NAME" "$s")
        if [ "$s_name" = "$i_name" ]; then
          s_nohup=$(readserviceprop "NOHUP" "$s")
        fi
      done
      if [ -z "$s_nohup" ]; then
        canhup="$_true"
      else
        case "$s_nohup" in
          true|TRUE|1|yes|YES|y|Y)
            canhup="$_false"
            ;;
          *)
            canhup="$_true"
            ;;
        esac
      fi
      if [ "$canhup" -eq "$_false" ]; then
        printf 'cannot hup service %s\n' "$s_name"
      else
        printf ' sending hup to %s\t%s\n' "$s_pid" "$s_name"
        if kill -0 "$s_pid" 2>/dev/null; then
          [ -z "$dry_run" ] && kill -HUP "$s_pid"
        fi
      fi
    done
  else
    for i in "${ServicesDir}"/* ; do
      ServiceFileName="${i##*/}"
      if [ "$ServiceFileName" = "$1" ]; then
        s_name=$(readserviceprop "NAME" "$i")
        s_nohup=$(readserviceprop "NOHUP" "$i")
        if [ -z "$s_nohup" ]; then
          canhup="$_true"
        else
          case "$s_nohup" in
            true|TRUE|1|yes|YES|y|Y)
              canhup="$_false"
              ;;
            *)
              canhup="$_true"
              ;;
          esac
        fi
        if [ "$canhup" -eq "$_false" ]; then
          printf 'cannot hup service %s\n' "$s_name"
        else
          if [ -f "${GUISessionDir}/${s_name}.pid" ]; then
            s_pid=$(read_file "${GUISessionDir}/${s_name}.pid")
            printf ' sending hup to %s\t%s\n' "$s_pid" "$s_name"
            if kill -0 "$s_pid" 2>/dev/null; then
              [ -z "$dry_run" ] && kill -HUP "$s_pid"
            fi
          else
            printf 'service %s not running\n' "$s_name"
          fi
        fi
      fi
    done
  fi
}

# Usage: killchilds all | <service name>
#   all: status for all services
#   <service name>: status of service
#
# Return: string
killchilds() {
  if [ -z "$1" ] || [ "all" = "$1" ]; then
    for i in "${GUISessionDir}"/*.pid ; do
      s_pid=$(read_file "$i")
      # s_name=$(ps -p "$s_pid" -o comm=)
      s_name="${i##*/}"
      printf ' sending term to %s\t%s\n' "$s_pid" "$s_name"
      if kill -0 "$s_pid" 2>/dev/null; then
      [ -z "$dry_run" ] && kill "$s_pid"
      fi
      [ -z "$dry_run" ] && rm -f "$i"
    done
  else
    for i in "${ServicesDir}"/* ; do
      ServiceFileName="${i##*/}"
      if [ "$ServiceFileName" = "$1" ]; then
        s_name=$(readserviceprop "NAME" "$i")
        if [ -f "${GUISessionDir}/${s_name}.pid" ]; then
          s_pid=$(read_file "${GUISessionDir}/${s_name}.pid")
          printf ' sending term to %s\t%s\n' "$s_pid" "$s_name"
          if kill -0 "$s_pid" 2>/dev/null; then
          [ -z "$dry_run" ] && kill "$s_pid"
          fi
          [ -z "$dry_run" ] && rm -f "${GUISessionDir}/${s_name}.pid"
        else
          printf 'service %s not running\n' "$s_name"
        fi
      fi
    done
  fi
}

# Usage: daemon_send <action> all | <service name>
#   <action>: hup, stop, start, reload
#   all: apply action to all services
#   <service name>: service to kill
#
# Return: void
daemon_send() {
  printf '%s %s\n' "$1" "$2" > "${GUISessionDir}/socket"
}

# Usage: kill_session
# Return: void
kill_session() {
  killchilds "all"
  [ -z "$dry_run" ] && rm -rf "$GUISessionDir"
  [ -z "$dry_run" ] && kill "$GUI_SESSION_PID"
}

show_help() {
  printf 'Usage: %s [options] { hup | start | stop | restart } [service name] | logout \n' "$myname"
  printf '  -n        dry run.\n  -h        show this help.\n'
  printf '  -p        pretty print reply.\n'
  printf '   hup      send hup to the session service(s)\n'
  printf '   stop     send term to the session service(s)\n'
  printf '   start    send request to start the session service(s)\n'
  printf '   restart  send term to the session service(s) and then send request to start the service(s)\n'
  printf '   logout   send term to the session services and the xsession process\n'
  printf '   reload   send term to the session services and reload shed\n'
  printf '   status   shows the status of the desired service'
  printf 'for all services the status is shown with a symbol as follows:\n'
  printf '\t     [ + ] means the service is running\n'
  printf '\t     [ - ] means the service is not running\n'
  printf '\t     [ ? ] means the service was started but the pid was not among the active processes\n'
}

OPTIND=1
while getopts nhp o; do case "${o}" in
  h) help=1 ;;
  n) dry_run=1 ;;
  p) PrettyPrint=1 ;;
  *) help=1 ;;
esac done
shift $(( OPTIND - 1 ))

[ -z "$invalid" ] || { show_help ; exit 1 ;}
[ -z "$help" ] || { show_help ; exit; }
case $1 in
  stop)
    killchilds "$2"
  ;;
  restart)
    killchilds "$2"
    progspinner "restarting service(s)" 1
    daemon_send "start" "$2"
    read_reply
  ;;
  hup)
    hupprocs "$2"
  ;;
  status)
    procstat "$2"
  ;;
  start)
    daemon_send "start" "$2"
    read_reply
  ;;
  logout)
    kill_session
  ;;
  reload)
    killchilds "all"
    progspinner "reloading shed" 2
    daemon_send "reload"
    read_reply
  ;;
  *) show_help ; exit 1 ;;
esac

# cd "$OldWorkDir"