systemctl

#!/bin/bash
#
# @file systemctl-fake
# @license MIT
# @author kvaps <kvaps at github.com> (c) Copyright 2017
# @author gmt4 <gmt4 at github.com> (c) Copyright 2022
# @git: https://github.com/gmt4/fake-systemd/
#
# upper vars:     like UNIT* are in exec_action context
# lower vars:     in local function
# camelcase vars: systemd params var
#

PROGNAME=${0##*/}
PROGVERSION=v1.0
PROGAUTHOR=gmt4
PROGURL="https://github.com/gmt4/fake-systemd"

# set -euf

startstopdaemon="$(command -v start-stop-daemon)"

get_unit_file(){
    # Check for Alias=unit.service
    Alias=$(grep -hr "^Alias=${UNIT}" "${UNIT_PATHS[@]}" 2>/dev/null | sed -n 's/^Alias=//p')
    if [ -n "$Alias" ]; then
        UNIT="$Alias"
    fi

    for dir in ${UNIT_PATHS[@]} ;
    do
        if [ -f "${dir}${UNIT}" ]; then
            echo "${dir}${UNIT}"
            break
        fi
        if [ -f "${dir}${UNIT}.service" ] ; then
            echo "${dir}${UNIT}.service"
            break
        fi
    done
}

read_option(){
    local option="$1"

    value="$(grep '^'$option'[= ]' "$UNIT_FILE" | cut -d '=' -f2- | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
    value="$(
        echo $value |
        sed -e "s/%[i]/$UNIT_INSTANCE/g" \
            -e "s/%[I]/\"$UNIT_INSTANCE\"/g" \
            -e "s/%[n]/$UNIT_FULL/g" \
            -e "s/%[N]/\"$UNIT_FULL\"/g"
    )"
    # TODO: Add more options from:
    # https://www.freedesktop.org/software/systemd/man/systemd.unit.html#Specifiers

    if [ -n "$value" ];
    then
        echo $value
        return
    else
        for include in $(grep '^.include' "$UNIT_FILE" | sed 's/^\.include[[:space:]]*//'); do
            recurse_value=$(UNIT_FILE=$include read_option $option)
            if [ -n "$recurse_value" ]; then
                echo $recurse_value
                return
            fi
        done
    fi

}

read_multioption(){
    local option="$1"

    (
        sed ':a;N;$!ba;s/\\[[:space:]]*\n//g' "$UNIT_FILE" |
        grep '^'$option'[= ]' | cut -d '=' -f2- |
        sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'
    ) |
        while IFS= read -r line;
        do
            echo "$line" |
                sed -e "s/%[i]/$UNIT_INSTANCE/g" \
                    -e "s/%[I]/\"$UNIT_INSTANCE\"/g" \
                    -e "s/%[n]/$UNIT_FULL/g" \
                    -e "s/%[N]/\"$UNIT_FULL\"/g"
        done

    # TODO: Add more options from:
    # https://www.freedesktop.org/software/systemd/man/systemd.unit.html#Specifiers
}

get_unit_wants() {
    (
        # Print wants from UNIT_PATHS
        for DIR in ${UNIT_PATHS[@]} ; do
            if [ -d "${DIR}${UNIT}.wants" ] ; then
                ls -1 "${DIR}${UNIT}.wants/" | tr '\n' ' '
            fi
        done

        # Print wants from unit-file
        read_option Wants $UNIT_FILE
    ) | sort -u
}

action_eval(){
    echo "${@}" |
        while IFS=$'\n' read -r -a i; do
            # ignore errors
            $(eval echo "$i") || echo
        done
}

action_start(){
    # Start depended services
    for unit in ${UNIT_WANTS[@]}; do
        exec_action start $unit
    done

    # Load options
    local User=$(read_option User)
    local Type=$(read_option Type)
    local PIDFile=$(read_option PIDFile)
    local EnvironmentFile=$(read_option EnvironmentFile | sed 's/^-//')
    local WorkingDirectory=($(read_option WorkingDirectory))
    local ExecStart=($(read_option ExecStart))
    local ExecStartPre=$(read_multioption ExecStartPre)
    local ExecStartPost=$(read_multioption ExecStartPost)
    local Environment=$(read_multioption Environment)

    # export Environement
    for envvar in $Environment; do
        eval $(echo "export $envvar")
    done

    # From doc: oneshot are the only service units that may have more than one
    # ExecStart= specified. They will be executed in order until either they
    # are all successful or one of them fails.
    # Note that systemd will consider the unit to be in the state "starting"
    # until the program has terminated, so ordered dependencies will wait
    # for the program to finish before starting themselves. The unit will
    # revert to the "inactive" state after the execution is done, never
    # reaching the "active" state. That means another request to start
    # the unit will perform the action again.
    if [[ "${Type,,}" == *"oneshot"* ]]; then
        local ExecStart=$(read_multioption ExecStart)

        action_eval "${ExecStartPre[@]}"
        action_eval "${ExecStart[@]}"
        action_eval "${ExecStartPost[@]}"

    elif [ -z "$Type" ] || [[ "${Type,,}" == *"simple"* ]] || [[ "${Type,,}" == *"notify"* ]] || [[ "${Type,,}" == *"forking"* ]] ; then

        makepid=""
        if [ -z "$PIDFile" ]; then
            PIDdir="/run/${UNIT_NAME}"

            mkdir -p $PIDdir
            [ -n "$User" ] && chown $User $PIDdir
            PIDFile="${PIDdir}/${UNIT_NAME}.pid"
            makepid="--make-pidfile"
        fi

        [ -f "$EnvironmentFile" ] && source "$EnvironmentFile"

        cmd=("$startstopdaemon --background --start --pidfile $PIDFile $makepid")

        [ -f "$WorkingDirectory" ] && cmd+=("--chdir $WorkingDirectory")
        [ -n "$User" ] && cmd+=("--chuid $User")

        cmd+=(--exec "${ExecStart[0]}" -- "${ExecStart[@]:1}")

        action_eval "${ExecStartPre[@]}"

        eval "$(echo "${cmd[@]}")"

        action_eval "${ExecStartPost[@]}"
    else
        >&2 echo "Unknown service type $Type"
    fi
}

action_stop(){
    # Load options
    local User=$(read_option User)
    local Type=$(read_option Type)
    local PIDFile=$(read_option PIDFile)
    local EnvironmentFile=$(read_option EnvironmentFile | sed 's/^-//')
    local ExecStop=$(read_option ExecStop)
    local ExecStopPre=$(read_multioption ExecStopPre)
    local ExecStopPost=$(read_multioption ExecStopPost)
    local Environment=$(read_multioption Environment)

    [ -z "$PIDFile" ] && PIDFile="/run/${UNIT_NAME}/${UNIT_NAME}.pid"
    [ -f "$EnvironmentFile" ] && source "$EnvironmentFile"

    # export Environement
    for envvar in $Environment; do
        eval $(echo "export $envvar")
    done


    # Stop service
    if [ -z "$ExecStop" ] ; then
        cmd="$startstopdaemon --stop --pidfile $PIDFile"
        [ -n "$User" ] && cmd+=("--chuid $User")
    else
        cmd="$ExecStop"
        [ -n "$User" ] && cmd="runuser -m -u $User -- $cmd"
    fi

    action_eval "${ExecStopPre[@]}"

    eval "$(echo "${cmd[@]}")"

    action_eval "${ExecStopPost[@]}"
}

action_restart(){
    action_stop
    sleep 1
    action_start
}

action_show(){
    cat $UNIT_FILE
    echo MainPID=$(_get_pid)
}

action_reload(){
    local User=$(read_option User)
    local ExecReload=$(read_multioption ExecReload)
    local EnvironmentFile=$(read_option EnvironmentFile | sed 's/^-//')
    local Environment=$(read_multioption Environment)

    # export Environement
    for envvar in $Environment; do
        eval $(echo "export $envvar")
    done

    [ -f "$EnvironmentFile" ] && source "$EnvironmentFile"

    cmd="${ExecReload[@]}"
    [ -n "$User" ] && cmd="runuser -m -u $User -- $cmd"
    eval "$(echo "${cmd[@]}")"
}

action_enable(){
    local WantedBy=$(read_option WantedBy)

    if [ -z "$WantedBy" ] ; then
        >&2 echo "Unit $UNIT have no WantedBy option."
        exit 1
    fi

    local WANTEDBY_DIR="/etc/systemd/system/$WantedBy.wants"

    if [ ! -f "$WANTEDBY_DIR/$UNIT_FULL" ] ; then
        mkdir -p "$WANTEDBY_DIR"
        echo "Created symlink from $WANTEDBY_DIR/$UNIT_FULL to $UNIT_FILE."
        ln -s "$UNIT_FILE" "$WANTEDBY_DIR/$UNIT_FULL"
    fi
}

action_disable(){
    local WantedBy=$(read_option WantedBy)

    if [ -z "$WantedBy" ] ; then
        >&2 echo "Unit $UNIT have no WantedBy option."
        exit 1
    fi

    local WANTEDBY_DIR="/etc/systemd/system/$WantedBy.wants"

    if [ -f "$WANTEDBY_DIR/$UNIT_FULL" ] ; then
        echo "Removed $WANTEDBY_DIR/$UNIT_FULL."
        rm -f "$WANTEDBY_DIR/$UNIT_FULL"
        rmdir --ignore-fail-on-non-empty "$WANTEDBY_DIR"
    fi
}

action_isenabled(){
    local WantedBy=$(read_option WantedBy)

    if [ -z "$WantedBy" ] ; then
        echo "unknown"
    else
        local WANTEDBY_DIR="/etc/systemd/system/$WantedBy.wants"
        if [ -f "$WANTEDBY_DIR/$UNIT_FULL" ] ; then
            echo "enabled"
            exit 0
        else
            echo "disabled"
            exit 1
        fi
    fi
}

action_isactive(){
    pid=$(_get_pid)

    # set default pifile
    [ "$pid" == "-1" ] && echo "unknown" && exit 3

    # check if the pid exists - systemctl returns 3
    [ -r "/proc/$pid/status" ] || kill -0 "$pid" > /dev/null 2>&1
    if [ $? -eq 0 ]; then
        echo "active"
        exit 0
    else
        echo "inactive"
        exit 3
    fi
}

_get_pid(){
    local PIDFile=$(read_option PIDFile)
    local GuessMainPID=$(read_option GuessMainPID)
    local ExecStart=($(read_option ExecStart))

    GuessMainPID="${GuessMainPID:-yes}"
    if [ "$GuessMainPID" == "yes" ];
    then
        pgrep --oldest -f -- "${ExecStart}" && return
    fi

    # set default pifile
    if [ -z "$PIDFile" ];
    then
        for PIDFile in "/run/${UNIT_NAME}.pid" "/run/${UNIT_NAME}/${UNIT_NAME}.pid"
        do
            if [ -f "$PIDFile" ]; then break; fi
        done
    fi

    # now check if the pidfile exists
    if [ ! -f "$PIDFile" ]; then
        echo "-1"
    else
        cat "$PIDFile"
    fi
}

action_status(){
    local Description="$(read_option Description)"
    local Documentation="$(read_option Documentation)"

    local color_red="\033[1;31m"
    local color_green="\033[1;32m"
    local color_reset="\033[0m"
    local color_curr="$color_reset"

    pid=$(_get_pid)
    isenabled=$(action_isenabled)
    isactive=$(action_isactive)
    status="inactive (dead)"
    if [ "$isactive" == "failed" ]; then
        color_curr=$color_red
        status="${color_curr}$isactive${color_reset} (Result: NI)"
    elif [ "$isactive" == "active" ]; then
        color_curr=$color_green
        psdate=$(ps -p "$pid" -o lstart=)
        pscmd=($(ps -p "$pid" -o cmd=))
        psmem=$(ps -p "$pid" -o %mem= | tr -d ' ')
        status="${color_curr}$isactive (running)${color_reset} since $psdate"
    fi

    echo -e "${color_curr}●${color_reset} $UNIT - $Description"
    echo -e "   Loaded: loaded ($UNIT_FILE; $isenabled; vendor preset: NI)"
    echo -e "   Active: $status"
    if [ -n "$Documentation" ]; then
       echo "     Docs: $Documentation"
    fi
    if [ "$isactive" == "active" ]; then
        local ExecStartPre="$(read_multioption ExecStartPre)"
        if [ -n "$ExecStartPre" ]; then
            echo "  Process: $pid ExecStartPre=$ExecStartPre"
        fi
        echo " Main PID: $pid ($(basename ${pscmd[0]}))"
        echo "   Memory: $psmem%"
        echo "   CGroup: /system.slice/$UNIT"
        echo "           └─$pid ${pscmd[@]}"
    fi
    echo
}

action_list_units(){
    local Description="$(read_option Description)"
    local isenabled=$(action_isenabled)
    local isactive=$(action_isactive)
    printf "$UNIT\t$isenabled $isactive $Description\n"
}

helper_list_units(){
    for dir in ${UNIT_PATHS[@]} ;
    do
        [ -d "$dir" ] && ls -1 $dir
    done
}

exec_action(){
    local ACTION=$1
    local UNIT=$2

    [[ "$UNIT" =~ '.' ]] || UNIT="$UNIT.service"

    local UNIT_NAME="${UNIT%%.*}"

    if [[ $UNIT =~ '@' ]] ; then
        local UNIT_INSTANCE="${UNIT##*@}"
        local UNIT="${UNIT%%$UNIT_INSTANCE}"
    fi

    local UNIT_FILE="$(get_unit_file "$UNIT")"
    if [ -z "$UNIT_FILE" ] || [ ! -f "$UNIT_FILE" ]
    then
        >&2 echo "Unit $UNIT could not be found."
        return
    fi

    local UNIT_FULL="$(echo "$UNIT" | sed "s/@/@$UNIT_INSTANCE/")"
    local UNIT_WANTS=($(get_unit_wants "$UNIT"))

    # Systemd env variables
    # https://www.freedesktop.org/software/systemd/man/systemd.service.html
    local MAINPID=$(_get_pid)

    case "$ACTION" in
        status )    action_status ;;
        start )     action_start ;;
        stop )      action_stop ;;
        restart )   action_restart ;;
        reload )    action_reload ;;

        try-restart) action_isactive && action_restart ;;
        reload-or-restart) action_reload || action_restart ;;

        enable )    action_enable ;;
        disable )   action_disable ;;
        is-active ) action_isactive ;;
        is-enabled ) action_isenabled ;;
        show)       action_show ;;
        list-units) action_list_units;;

        help ) >&2 echo "This command expects one or more unit names. Did you mean --help?" ; return ;;
        -h )        usage; return 0 ;;
        --help )    usage; return 0 ;;
        # exit 0 if unknown operation to avoid errors
        # like mask, unmask etc
        *) action_unknown "$@" ; exit 1 ;;
    esac
}

action_daemonreload()
{
    action_nop "$@"
    sleep 0.5
}

action_unknown(){
    >&2 echo "$PROGNAME: Warning unknown op $*"
}

action_nop(){
    >&2 echo "$PROGNAME: Warning nop $*"
}

usage(){
    local USAGE="$PROGNAME [OPTIONS...] {COMMAND} ...
$(version)

Query or send control commands to the systemd manager.

Options:
  -h --help           Show this help
  -v --version        Show this version.

Unit Commands:
  start NAME...                   Start (activate) one or more units
  stop NAME...                    Stop (deactivate) one or more units
  restart NAME...                 Start or restart one or more units
  is-active PATTERN...            Check whether units are active
  status [PATTERN...|PID...]      Show runtime status of one or more units
  list-units [UNITS...]           List runtime status of one or more units

Unit File Commands:
  enable NAME...                  Enable one or more unit files
  disable NAME...                 Disable one or more unit files
  is-enabled NAME...              Check whether unit files are enabled
"

    echo -e "$USAGE"
}

version(){
    echo "$PROGNAME (fake) # @version $PROGVERSION (c) $PROGAUTHOR $PROGURL (forks kvaps/fake-systemd)"
}

main(){
    local ACTION="$1"
    local UNITS="${@:2}"
    local UNIT_PATHS=(
        /lib/systemd/system/
        /etc/systemd/system/
        /usr/lib/systemd/system/
    )

    if [ -z "$UNITS" ];
    then
        case "$ACTION" in
            status|start|stop|restart|reload) ;;
            enable|disable|is-active|is-enabled) ;;

            daemon-reload) action_daemonreload; return ;;

            show) ;;
            ls-units) helper_list_units;;
            list-units) UNITS=$(helper_list_units);;
            '')         usage; exit 0 ;;
            -h)         usage; exit 0 ;;
            help)       usage; exit 0 ;;
            --help)     usage; exit 0 ;;
            --version)  version; exit 0 ;;
            *) action_unknown "$@" ; exit 1 ;;
        esac
    else
        case "$ACTION" in
            --system) shift; ACTION="$1"; UNITS="${@:2}" ;;
            set-environment|unset-environment) action_unknown "$@"; return ;;
        esac
    fi

    if [ -z "$startstopdaemon" ];
    then
        >&2 echo "$PROGNAME: Error start-stop-daemon not found"
    fi

    for UNIT in ${UNITS[@]};
    do
        exec_action $ACTION $UNIT
    done
}

main "$@"