manage-ghar

#!/bin/bash

set -eu

PID_FILE="runner.pid"
LOG_FILE="runner.log"
STATE_DIRNAME="state"
CONFIG_FILE=".manage_ghar.conf"
VERSION="0.2.1"

DEBUG=false
QUIET=false

# check if runner is running based on the existence of a state file and based
# on a valid PID
is_running () {
    local state_path="$1"

    # if no PID file, it's not running
    if [[ ! -f $state_path/$PID_FILE ]]
    then
        return 1
    fi

    local pid
    pid=$(cat "$state_path/$PID_FILE")

    # check PID exists
    if ps -p "$pid" >/dev/null
    then
        return 0
    else
        return 1
    fi
}

# check if the provided command, either a command or a path to an executable,
# is valid
command_is_valid () {
    local command="$1"

    # check command is within PATH and valid
    if type "$command" >/dev/null 2>&1
    then
        return
    fi

    # check the path command exists and is executable
    if ! [[ -f "$command" ]]
    then
        message_error "Command $command not found"
        return 12
    fi
    if ! [[ -x "$command" ]]
    then
        message_error "Command $command not executable"
        return 13
    fi
}



start () {
    local runner_path="$1"
    local state_path="$2"
    local runner_command="$3"
    local force=$4

    # check if the runner path exists
    if ! [[ -d "$runner_path" ]]
    then
        message_error "Runner path not found"
        return 10
    fi

    # check if the runner is running
    if ! $force && is_running "$state_path"
    then
        message_info "The runner is already running"
        return 0
    fi

    # running as a service, see
    # https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/configuring-the-self-hosted-runner-application-as-a-service
    if [[ -z "$runner_command" ]]
    then
        runner_command="bin/runsvc.sh"
    fi

    cd "$runner_path"

    # check if runner command is valid
    command_is_valid "$runner_command"

    message_info "Starting runner"
    echo "Starting runner on $(hostname)" >>"$state_path/$LOG_FILE"
    $runner_command >>"$state_path/$LOG_FILE" 2>&1 &

    # create pid file
    message_debug "Creating pid file"
    echo $! >"$state_path/$PID_FILE"
}

stop () {
    local state_path="$1"

    # check if the runner is running
    if is_running "$state_path"
    then
        local pid
        pid=$(cat "$state_path/$PID_FILE")

        message_info "Stopping runner"
        echo "Stopping runner on $(hostname)" >>"$state_path/$LOG_FILE"
        kill -SIGTERM "$pid"
    else
        message_info "Runner already stopped"
        echo "Runner already stopped on $(hostname)" >>"$state_path/$LOG_FILE"
    fi

    message_debug "Removing PID file"
    rm --force "$state_path/$PID_FILE"
}

status () {
    local state_path="$1"

    if is_running "$state_path"
    then
        message_info "Runner started"
    else
        message_info "Runner stopped"
    fi
}

message_debug () {
    local message="$*"

    if $DEBUG && ! $QUIET
    then
        echo "$message"
    fi
}

message_info () {
    local message="$*"

    if ! $QUIET
    then
        echo "$message"
    fi
}

message_warning () {
    local message="$*"

    echo "Warning: $message" >&2
}

message_error () {
    local message="$*"

    echo "Error: $message" >&2
}

usage () {
    cat <<EOF
Manage GitHub Actions Runner like a SysV init script

manage-ghar [-s STATE_PATH] [-r RUNNER_COMMAND] [-f] [-d] [-q] [-v] [-h] {start|stop|restart|status} RUNNER_PATH

Optional arguments:
    -s STATE_PATH
        Path to the state directory of the manager (where PID and log files are stored). Default to $STATE_DIRNAME in the runner directory.
    -r RUNNER_COMMAND
        Command to execute instead of running the runner directly. This command should not take any argument.
    -f
        Force start even if the runner is running (may have unpredictable effects).
    -d
        Increase verbosity to debug messages.
    -q
        Decrease verbosity to warning and error messages.
    -v
        Show current version and return.
    -h
        Show this help message and return.

Subcommands:
    start
        Start the runner, it cannot be started twice. Runner's PID is stored in $PID_FILE and logs are outputed in $LOG_FILE, within the state directory.
    stop
        Stop the runner.
    restart
        Stop and start the runner.
    status
        Tell if the runner is running.

Mandatory arguments:
    RUNNER_PATH
        Path to a GitHub Actions Runner directory.
EOF
}

usage_extra () {
    cat <<EOF

If there is a configuration file $CONFIG_FILE in the user home directory, then manage-ghar will use it to set the default value of the following optional arguments:
    state_path
    runner_command
    force (true or false)
Arguments must be in the form "<key>=<value>". Arguments from the command line override those default values.
EOF
}

show_version () {
    echo "manage-ghar v$VERSION"
}

main () {
    # default arguments
    local state_path=""
    local runner_command=""
    local force=false

    # read configuration if available
    local config_file=$HOME/$CONFIG_FILE
    local config_loaded=false
    if [[ -f "$config_file" ]]
    then
        # shellcheck source=/dev/null
        source "$config_file"
        config_loaded=true
    fi

    # process optional arguments
    while getopts ":hvqds:r:f" option
    do
        case $option in
            "h")
                usage
                usage_extra
                return 0
                ;;
            "v")
                show_version
                return 0
                ;;
            "q")
                QUIET=true
                ;;
            "d")
                DEBUG=true
                ;;
            "s")
                state_path="$OPTARG"
                ;;
            "r")
                runner_command="$OPTARG"
                ;;
            "f")
                force=true
                ;;
            *)
                message_error "Unknown option $OPTARG"
                usage
                return 1
                ;;
        esac
    done
    shift $((OPTIND-1))

    # process mandatory arguments
    if [[ -z "${1+_}" ]] || [[ -z "${2+_}" ]]
    then
        message_error "Missing arguments"
        usage
        return 2
    fi

    local subcommand="$1"
    local runner_path
    runner_path="$(realpath "$2")"

    # process state path
    if [[ -z $state_path ]]
    then
        state_path="$runner_path/$STATE_DIRNAME"
    else
        state_path="$(realpath "$state_path")"
    fi

    # print debug config
    if $config_loaded
    then
        message_debug "Config loaded from $config_file"
    fi
    message_debug "State path: $state_path"
    message_debug "Runner command: $runner_command"
    message_debug "Force: $force"
    message_debug "Subcommand: $subcommand"
    message_debug "Runner path: $runner_path"

    mkdir -p "$state_path"

    # process subcommand
    case $subcommand in
        "start")
            start "$runner_path" "$state_path" "$runner_command" "$force"
            return 0
            ;;
        "stop")
            stop "$state_path"
            return 0
            ;;
        "restart")
            stop "$state_path"
            sleep 1
            start "$runner_path" "$state_path" "$runner_command" "$force"
            return 0
            ;;
        "status")
            status "$state_path"
            return 0
            ;;
        *)
            message_error "Unknown subcommand $subcommand"
            usage
            return 3
            ;;
    esac
}

main "$@"