#!/bin/sh

: << =cut

=head1 Name

munin-get - a simple tool for managing plugins from remote repositories


=head1 Features

The small management tool "munin-get" supports the following actions:

=over

=item clone one or more git repositories containing munin plugins

=item multiple remote repositories can be used

=item list all found plugins (including change timestamp and description)

=item "install" a plugin (by default to: /var/lib/munin/munin-get-plugins)

=item "enable" a plugin (create a symlink to /etc/munin/plugins/)

=item upgrade plugins (and review changes before)

=back

The primary purpose of this tool is the simplification of the process of using plugins from munin's
contrib repository.


=head1 Usage

All actions except "install", "enable" and "disable" can be run as a regular user.  Please note
that the non-privileged commands use directories relative to $HOME by default (can be overridden).
Thus sudo or a similar tool should be used for gaining privileges.  Of course, everything can also
be done as root.

The separate "install" step works around potential problems with systemd hardening flags or other
security policies, which may prevent files in /root/ or below /home/ from being accessed by
the "munin-node" service process.


=head1 Examples

=head2 Discover, inspect, install, enable and test a plugin

    munin-get update
    munin-get list
    munin-get search throughput
    munin-get doc contrib/traffic
    munin-get install contrib/traffic
    munin-get enable contrib/traffic
    munin-run traffic
    service munin-node restart   # for systemd: systemctl restart munin-node

=head2 Review and apply changes from the upstream repository

    munin-get update
    munin-get list-upgradeable
    munin-get diff-upgradeable
    munin-get upgrade

=head2 Add custom 3rd party git repositories

    munin-get add-repository foo http://example.org/repos/munin-plugins.git
    munin-get add-repository bar http://example.org/repos/munin-stuff.git branch-tested plugins/
    munin-get update


=head1 Internals

Repositories are cloned below ~/.cache/munin/munin-get/repositories (see REPOSITORY_CACHE_BASE_DIR).

Manual changes in the cloned repositories should be avoided.

The separate "install" and "enable" procedure is necessary due to possible process namespace /
hardening features enabled for "munin-node". Thus the target of the symlink is located in a path
that can be expected to be usable even for a restricted "munin-node" process.

Additionally the separate "install" location allows the manual review of upstream changes before
applying these locally.


=head1 Author

Lars Kruse <devel@sumpfralle.de>


=head1 License

  GPLv3+

=cut


set -eu


# cache directory (can be removed without harm)
MUNIN_GET_CACHE_DIR=${MUNIN_GET_CACHE_DIR:-$HOME/.cache/munin/munin-get}
# configuration directory
MUNIN_GET_CONFIG_DIR=${MUNIN_GET_CONFIG_DIR:-$HOME/.local/share/munin/munin-get}
# location for mirrored munin plugin repositories
REPOSITORY_CACHE_BASE_DIR="$MUNIN_GET_CACHE_DIR/repositories"
# location for generated man pages
MANPAGE_CACHE_BASE_DIR="$MUNIN_GET_CACHE_DIR/manpages"
# location for assembled meta data
METADATA_CACHE_BASE_DIR="$MUNIN_GET_CACHE_DIR/metadata"
# location for configuration files describing the specified munin plugin repositories
REPOSITORY_CONFIG_DIR="$MUNIN_GET_CONFIG_DIR/repositories"
# default plugin repository (mainainted by the munin community)
DEFAULT_REPO_MUNIN_CONTRIB_CONFIG='{"remote_url": "https://github.com/munin-monitoring/contrib.git", "branch": "master", "plugins_dir": "plugins"}'
# location of "installed" munin plugins (i.e. available at an accessible location - but maybe not installed, yet)
PLUGINS_INSTALL_DIR=${PLUGINS_INSTALL_DIR:-/var/lib/munin/munin-get-plugins}
# location of "enabled" munin plugins (munin-node uses this directory by default)
PLUGINS_ENABLE_DIR=${PLUGINS_ENABLE_DIR:-/etc/munin/plugins}


# emit an error message and exit with an error
error_die() {
    local text="$1"
    printf >&2 'ERROR: %s\n' "$text"
    exit 1
}


# emit a warning message to stderr
log_warning() {
    local text="$1"
    printf >&2 'WARNING: %s\n' "$text"
}


log_info() {
    local text="$1"
    printf '%s\n' "$text"
}


check_missing_executable() {
    local executable="$1"
    local package="$2"
    if ! command -v "$executable" >/dev/null; then
        error_die "Failed to find executable '$executable'. Please install the package '$package'."
    fi
}


check_dependencies() {
    check_missing_executable git git
    check_missing_executable jo jo
    check_missing_executable jq jq
}


check_doc_dependencies() {
    check_missing_executable man man
    if ! perldoc -V >/dev/null 2>&1; then
        error_die "Failed to run 'perldoc'. Please install the package 'perl-doc'."
    fi
}


# check a name (e.g. for a repository) for invalid characters
verify_simple_name() {
    local label_name="$1"
    local text="$2"
    echo "$text" | grep -q '^[[:alnum:]-]\+$' \
        || error_die "The '$label_name' parameter contains invalid characters. Only letters and numbers are allowed."
}


# create a minimized clone of a git repository
git_clone_minimal() {
    # The minimal set would include "--depth=1" - but we need the revisions in order to determine
    # the date of change for each plugin.
    git clone --quiet --single-branch --no-tags "$@"
}


# write the output of a given command to a file
# The output is not written, if the command fails.
write_safely_to_file() {
    local filename="$1"
    local output
    shift
    if output="$("$@")"; then
        if echo "$output" >"$filename.tmp"; then
            mv "$filename.tmp" "$filename"
        else
            rm -f "$filename.tmp"
        fi
        return 0
    else
        return 1
    fi
}


# Store the description of a plugin repository.  The repository is not cloned in this step.
add_repository() {
    local repo_name="$1"
    local remote_url="$2"
    local branch="$3"
    local plugins_dir="${4:-}"
    write_safely_to_file "$REPOSITORY_CONFIG_DIR/$repo_name.json" \
        jo -p name="$repo_name" remote_url="$remote_url" branch="$branch" plugins_dir="$plugins_dir"
}


# Check whether a local git repository exists.
verify_repository() {
    local repo_name="$1"
    [ -d "$REPOSITORY_CACHE_BASE_DIR/$repo_name/.git" ] \
        || error_die "there is no git repository ('$repo_name') at its expected location ($REPOSITORY_CACHE_BASE_DIR/$repo_name). Maybe you want to run 'munin-get update'?"
}


# Test whether a local git repository exists.  Create the repository based on the previously stored
# configuration, if the repository is not cloned, yet.
verify_or_create_repository() {
    local repo_name="$1"
    local remote_url target_dir branch
    [ -d "$REPOSITORY_CACHE_BASE_DIR/$repo_name/.git" ] && return 0
    if [ -n "$(get_repository_config_json "$repo_name")" ]; then
        remote_url=$(get_repository_config_value "$repo_name" "remote_url")
        branch=$(get_repository_config_value "$repo_name" "branch")
        log_info "Cloning git repository ..."
        create_repository "$remote_url" "$REPOSITORY_CACHE_BASE_DIR/$repo_name" "$branch"
    else
        error_die "Missing configuration for repository '$repo_name'"
    fi
}


# Test whether a specific plugin exists as a file in a repository.  No error messages are emitted.
exists_repository_plugin() {
    local repo_name="$1"
    local plugin_name="$2"
    [ -f "$(get_repository_plugin_filename "$repo_name" "$plugin_name")" ]
}


# Carefully check the existence of a plugin in a repository.  Failure messages are reported.
verify_repository_plugin() {
    local repo_name="$1"
    local plugin_name="$2"
    local relative_plugin_filename absolute_plugin_filename
    verify_repository "$repo_name"
    relative_plugin_filename=$(get_plugin_metadata_value "$repo_name" "$plugin_name" "filename")
    [ -z "$relative_plugin_filename" ] && error_die "Failed to determine filename of given plugin ($repo_name/$plugin_name). Maybe it does not exist?"
    absolute_plugin_filename="$REPOSITORY_CACHE_BASE_DIR/$repo_name/$relative_plugin_filename"
    [ -e "$absolute_plugin_filename" ] || error_die "Failed to find plugin file ($absolute_plugin_filename). Maybe the repository cache needs to be updated?"
}


# List the names of configured repositories.
get_repository_names() {
    {
        echo "contrib"
        if [ -d "$REPOSITORY_CONFIG_DIR" ]; then
            find "$REPOSITORY_CONFIG_DIR" -type d -mindepth 1 -maxdepth 1 -print0 \
                | xargs --null --no-run-if-empty basename --multiple \
                | grep -x '^[[:alnum:]-]\+$'
        fi
    } | sort | uniq
}


# Clone a git repository in the cache directory.
create_repository() {
    local remote_url="$1"
    local target_dir="$2"
    local branch="$3"
    if [ -n "$branch" ]; then
        git_clone_minimal --branch="$branch" "$remote_url" "$target_dir"
    else
        git_clone_minimal "$remote_url" "$target_dir"
    fi
}


# Retrieve the repository configuration as JSON.
get_repository_config_json() {
    local repo_name="$1"
    local filename="$REPOSITORY_CONFIG_DIR/$repo_name.json"
    if [ -e "$filename" ]; then
        cat "$filename"
    elif [ "$repo_name" = "contrib" ]; then
        echo "$DEFAULT_REPO_MUNIN_CONTRIB_CONFIG"
    else
        true
    fi
}


# Retrieve a value from the configuration of a repository.
get_repository_config_value() {
    local repo_name="$1"
    local key="$2"
    get_repository_config_json "$repo_name" | jq -r '.'"$key"'//""'
}


# Retrieve a value from the meta data of a plugin.
get_plugin_metadata_value() {
    local repo_name="$1"
    local plugin_name="$2"
    local key="$3"
    local metadata_filename="$METADATA_CACHE_BASE_DIR/$repo_name/$plugin_name.json"
    [ -e "$metadata_filename" ] || return 0
    jq -r '.'"$key"'//""' <"$metadata_filename"
}


# Retrieve the full filename of a plugin in a mirrored repository.
get_repository_plugin_filename() {
    local repo_name="$1"
    local plugin_name="$2"
    echo "$REPOSITORY_CACHE_BASE_DIR/$repo_name/$(get_plugin_metadata_value "$repo_name" "$plugin_name" "filename")"
}


# Synchronize the local plugin repository repository mirror with the upstream repository.
# Users are not supposed to interfere with these mirrored repositories.
update_repository() {
    local repo_name="$1"
    verify_or_create_repository "$repo_name"
    cd "$REPOSITORY_CACHE_BASE_DIR/$repo_name"
    log_info "Updating local git repository ..."
    git pull --quiet --ff-only
    log_info "Assembling meta data ..."
    update_repository_metadata "$repo_name"
}


# Test whether a target file is older than its dependency.
compiled_file_needs_update() {
    local source_file="$1"
    local target_file="$2"
    [ ! -e "$target_file" ] || [ -n "$(find "$source_file" -newer "$target_file")" ]
}


# Regenerate the manpage of a plugin via perldoc.
update_plugin_manpage() {
    local plugin_filename="$1"
    local manpage_filename="$2"
    # TODO: set "date"
    write_safely_to_file "$manpage_filename" \
        perldoc -o nroff -w "center:Munin Plugin ($repo_name)" -T -F "$plugin_filename"
}


# Update the meta data of a plugin (e.g. tile, update timestamp and description).
update_plugin_metadata() {
    local repo_name="$1"
    local plugin_name="$2"
    local relative_plugin_filename="$3"
    local metadata_filename="$4"
    local summary_cache_file="$5"
    local change_time description summary
    if compiled_file_needs_update "$relative_plugin_filename" "$metadata_filename"; then
        cd "$REPOSITORY_CACHE_BASE_DIR/$repo_name"
        change_time=$(git log -1 --format=%at "$relative_plugin_filename")
	description=$(perldoc -o nroff -T -F "$relative_plugin_filename" | sed '/^\.Vb [12]/d' | grep -A 1 '^.SH "NAME"$' | tail -1 | sed 's/^\(\\& *\)\?[^ ]* \\- \+//' | sed 's/\\//g')
        summary=$(printf '%s/%-30s %s %s\n' "$repo_name" "$plugin_name" "$(date +%Y-%m-%d --date="@$change_time")" "$description")
        write_safely_to_file "$metadata_filename" \
            jo -p -- "timestamp=$change_time" -s "description=$description" -s "summary=$summary" -s "filename=$relative_plugin_filename"
        # update the entry in the summary cache file
        [ -e "$summary_cache_file" ] || touch "$summary_cache_file"
        sed -i "#^$repo_name/$plugin_name #d" "$summary_cache_file"
        printf '%s\n' "$summary" >>"$summary_cache_file"
    fi
}


# Update the meta data of a repository. This includes the plugin's meta data and generated man
# pages.
update_repository_metadata() {
    local repo_name="$1"
    local plugin_name relative_plugin_filename
    mkdir -p "$MANPAGE_CACHE_BASE_DIR/$repo_name"
    mkdir -p "$METADATA_CACHE_BASE_DIR/$repo_name"
    list_repository_plugin_files "$repo_name" | while read -r relative_plugin_filename; do
        plugin_name=$(basename "$relative_plugin_filename")
        update_plugin_metadata "$repo_name" "$plugin_name" "$relative_plugin_filename" "$METADATA_CACHE_BASE_DIR/$repo_name/$plugin_name.json" "$METADATA_CACHE_BASE_DIR/$repo_name/_summary_cache.txt"
    done
}


# Show the man page of a plugin (via "man").
show_plugin_manpage() {
    local repo_name="$1"
    local plugin_name="$2"
    local manpage_filename="$MANPAGE_CACHE_BASE_DIR/$repo_name/$plugin_name"
    local plugin_filename
    plugin_filename=$(get_repository_plugin_filename "$repo_name" "$plugin_name")
    if compiled_file_needs_update "$plugin_filename" "$manpage_filename"; then
        log_info "Generating man page for $repo_name/$plugin_name ..."
        update_plugin_manpage "$plugin_filename" "$manpage_filename" \
            || error_die "Failed to generate man page: $repo_name/$plugin_name"
    fi
    man --local-file "$manpage_filename"
}


# Execute a given action for one or multiple repositories.  If no repositories are given, then the
# action is executed for all repositories.  This function is useful for command line handling.
do_for_some_or_all_repositories() {
    local action="$1"
    local repo_name
    shift
    if [ $# -gt 0 ]; then
        for repo_name in "$@"; do
            verify_simple_name "name" "$repo_name"
            "$action" "$repo_name"
        done
    else
        get_repository_names | while read -r repo_name; do
            "$action" "$repo_name"
        done
    fi
}


# List all plugin files found in a mirrored repository.
list_repository_plugin_files() {
    local repo_name="$1"
    local plugins_dir
    verify_repository "$repo_name"
    plugins_dir=$(get_repository_config_value "$repo_name" "plugins_dir")
    [ -z "$plugins_dir" ] && plugins_dir="."
    cd "$REPOSITORY_CACHE_BASE_DIR/$repo_name"
    find "$plugins_dir" -type f -executable | sed 's#^\./##' | sort
}


# List all plugins in a repository.  The output includes the last change timestamp and a plugin
# description.
list_repository_plugins() {
    local repo_name="$1"
    local relative_plugin_filename plugin_name summary_cache_filename
    summary_cache_filename="$METADATA_CACHE_BASE_DIR/$repo_name/_summary_cache.txt"
    if [ -e "$summary_cache_filename" ]; then
        sort "$summary_cache_filename"
    else
        list_repository_plugin_files "$repo_name" | while read -r relative_plugin_filename; do
            plugin_name=$(basename "$relative_plugin_filename")
            summary=$(get_plugin_metadata_value "$repo_name" "$plugin_name" "summary")
            echo "${summary:-$repo_name/$plugin_name}"
        done
    fi
}


# Split the input parameter into two tokens (separated by a slash).  The two tokens are output in
# separate lines.
split_slashed_repo_plugin_name() {
    local full_name="$1"
    local repo_name plugin_name
    echo "$full_name" | grep -q "/" || error_die "Invalid plugin name in repository ('$full_name'). Use REPOSITORY/PLUGIN instead."
    repo_name=$(echo "$full_name" | cut -f 1 -d /)
    plugin_name=$(echo "$full_name" | cut -f 2- -d /)
    verify_simple_name "name" "$repo_name"
    [ -n "$plugin_name" ] || error_die "Empty plugin name"
    echo "$repo_name"
    echo "$plugin_name"
}


ACTION=${1:-help}
[ $# -gt 0 ] && shift

case "$ACTION" in
    add-repository)
        [ $# -lt 2 ] && error_die "at least two parameters (name and remote_url) are required"
        [ $# -gt 4 ] && error_die "not more than four parameters (name, remote_url, branch, base_dir) are allowed"
        repo_name="$1"
        remote_url="$2"
        branch="${3:-}"
        plugins_dir="${4:-.}"
        check_dependencies
        verify_simple_name "name" "$repo_name"
        add_repository "$repo_name" "$remote_url" "$branch" "$plugins_dir"
        ;;
    remove-repository)
        [ $# -ne 1 ] && error_die "exactly one parameter (name) is required"
        repo_name="$1"
        check_dependencies
        verify_simple_name "name" "$repo_name"
        verify_repository "$repo_name"
        rm -rf "${REPOSITORY_CACHE_BASE_DIR:?}/$repo_name"
        rm -rf "${MANPAGE_CACHE_BASE_DIR:?}/$repo_name"
        rm -rf "${METADATA_CACHE_BASE_DIR:?}/$repo_name"
        rm -f "$REPOSITORY_CONFIG_DIR/$repo_name.json"
        ;;
    update)
        check_dependencies
        do_for_some_or_all_repositories "update_repository" "$@"
        ;;
    search)
        [ $# -ne 1 ] && error_die "exactly one parameter (a regular expression) is required"
        regex=$1
        check_dependencies
        get_repository_names | while read -r repo_name; do
            plugins_dir=$(get_repository_config_value "$repo_name" "plugins_dir")
            find "$REPOSITORY_CACHE_BASE_DIR/$repo_name/$plugins_dir" -type f -executable -print0 \
                | xargs --null -r grep --files-with-matches "$regex" \
                | xargs -r basename --multiple | sed "s#^#$repo_name #"
        done | sort | while read -r repo_name plugin_name; do
            summary=$(get_plugin_metadata_value "$repo_name" "$plugin_name" "summary")
            printf '%s\n' "$summary"
        done
        ;;
    list-repositories)
        check_dependencies
        get_repository_names
        ;;
    list)
        check_dependencies
        do_for_some_or_all_repositories "list_repository_plugins" "$@"
        ;;
    list-installed)
        check_dependencies
        get_repository_names | while read -r repo_name; do
            [ -d "$PLUGINS_INSTALL_DIR/$repo_name" ] || continue
            find "$PLUGINS_INSTALL_DIR/$repo_name" -type f -executable -print0 \
                | xargs -r -0 -n 100 basename --multiple \
                | sed "s#^#$repo_name/#"
        done
        ;;
    list-enabled)
        check_dependencies
        [ -d "$PLUGINS_ENABLE_DIR" ] || exit 0
        find "$PLUGINS_ENABLE_DIR" -type l | while read -r plugin_symlink; do
            target=$(readlink --canonicalize-missing "$plugin_symlink")
            repo_plugin_path=${target#${PLUGINS_INSTALL_DIR%/}/}
            [ "$repo_plugin_path" = "$target" ] && continue
            parsed=$(split_slashed_repo_plugin_name "$repo_plugin_path")
            repo_name=$(echo "$parsed" | sed -n 1p)
            plugin_name=$(echo "$parsed" | sed -n 2p)
            exists_repository_plugin "$repo_name" "$plugin_name" || continue
            echo "$repo_name/$plugin_name"
        done
        ;;
    list-upgradeable|diff-upgradeable)
        check_dependencies
        "$0" list-installed | while read -r repo_plugin_path; do
            parsed=$(split_slashed_repo_plugin_name "$repo_plugin_path")
            repo_name=$(echo "$parsed" | sed -n 1p)
            plugin_name=$(echo "$parsed" | sed -n 2p)
            plugin_filename=$(get_repository_plugin_filename "$repo_name" "$plugin_name")
            install_target_filename="$PLUGINS_INSTALL_DIR/$repo_name/$plugin_name"
            if [ ! -e "$plugin_filename" ]; then
                log_warning "Missing plugin file in repository cache ($plugin_filename)"
                continue
            fi
            if [ ! -e "$install_target_filename" ]; then
                log_warning "Missing installed plugin file ($install_target_filename)"
                continue
            fi
            case "$ACTION" in
                list-upgradeable)
                    cmp --silent "$plugin_filename" "$install_target_filename" || echo "$repo_name/$plugin_name"
                    ;;
                diff-upgradeable)
                    diff -ruN "$install_target_filename" "$plugin_filename"
                    ;;
                *)
                    ;;
            esac
        done
        ;;
    doc|install|upgrade|uninstall|enable|disable)
        # the special action "upgrade" may be used without parameters
        if [ "$ACTION" = "upgrade" ] && [ $# -eq 0 ]; then
            "$0" list-upgradeable | while read -r repository_plugin; do
                "$0" upgrade "$repository_plugin"
            done
            exit 0
        fi
        [ $# -ne 1 ] && error_die "exactly one parameter (plugin name in repository) is required"
        repo_plugin_path="$1"
        check_dependencies
        parsed=$(split_slashed_repo_plugin_name "$repo_plugin_path")
        repo_name=$(echo "$parsed" | sed -n 1p)
        plugin_name=$(echo "$parsed" | sed -n 2p)
        verify_repository_plugin "$repo_name" "$plugin_name"
        source_filename=$(get_repository_plugin_filename "$repo_name" "$plugin_name")
        install_target_filename="$PLUGINS_INSTALL_DIR/$repo_name/$plugin_name"
        enabled_symlink="$PLUGINS_ENABLE_DIR/$plugin_name"
        not_installed_message="Plugin is not installed ($install_target_filename)."
        not_installed_message_with_hint="$not_installed_message Run '$(basename "$0") install $repo_plugin_path' before."
        not_enabled_message="Plugin is not enabled ($enabled_symlink)."
        case "$ACTION" in
            doc)
                check_doc_dependencies
                show_plugin_manpage "$repo_name" "$plugin_name"
                ;;
            install)
                if [ -e "$install_target_filename" ]; then
                    log_warning "Plugin is already installed ($install_target_filename)"
                else
                    mkdir -p "$PLUGINS_INSTALL_DIR/$repo_name"
                    cp "$source_filename" "$install_target_filename"
                fi
                ;;
            uninstall)
                if [ -e "$enabled_symlink" ]; then
                    error_die "Refusing to uninstall plugin, while it is enabled ($enabled_symlink)"
                elif [ -e "$install_target_filename" ]; then
                    rm "$install_target_filename"
                else
                    log_warning "$not_installed_message"
                fi
                ;;
            upgrade)
                if [ -e "$install_target_filename" ]; then
                    cp "$source_filename" "$install_target_filename"
                else
                    error_die "$not_installed_message_with_hint"
                fi
                ;;
            enable)
                if [ -e "$enabled_symlink" ]; then
                    log_warning "Plugin is already enabled ($enabled_symlink)"
                else
                    [ -e "$install_target_filename" ] || error_die "$not_installed_message_with_hint"
                    ln -s "$install_target_filename" "$enabled_symlink"
                fi
                ;;
            disable)
                if [ -e "$enabled_symlink" ]; then
                    rm "$enabled_symlink"
                else
                    log_warning "$not_enabled_message"
                fi
                ;;
            *)
                error_die "Internal error - unexpected action: $ACTION"
                ;;
        esac
        ;;
    clean)
        rm -rf "${REPOSITORY_CACHE_BASE_DIR:?}"
        rm -rf "${MANPAGE_CACHE_BASE_DIR:?}"
        rm -rf "${METADATA_CACHE_BASE_DIR:?}"
        ;;
    help|--help)
        echo "Syntax:  $(basename "$0") ACTION [ARGS [..]]"
        echo "    add-repository      NAME REMOTE_URL [BRANCH [PLUGINS_DIR]]"
        echo "    remove-repository   NAME"
        echo "    list-repositories"
        echo "    list-upgradeable"
        echo "    diff-upgradeable"
        echo "    update              [REPOSITORY [..]]"
        echo "    list                [REPOSITORY [..]]"
        echo "    search              REGULAR_EXPRESSION"
        echo "    doc                 REPOSITORY/PLUGIN_NAME"
        echo "    install             REPOSITORY/PLUGIN_NAME"
        echo "    uninstall           REPOSITORY/PLUGIN_NAME"
        echo "    upgrade             [REPOSITORY/PLUGIN_NAME]"
        echo "    enable              REPOSITORY/PLUGIN_NAME"
        echo "    disable             REPOSITORY/PLUGIN_NAME"
        echo "    clean"
        echo "    help"
        echo
        ;;
    *)
        "$0" help >&2
        exit 1
        ;;
esac
