puavo-pkg

#!/bin/bash
# Copyright (C) 2015 Opinsys Oy
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

g_puavo_pkg_cachedir=/var/cache/puavo-pkg
g_puavo_pkg_rootdir=/var/lib/puavo-pkg

LOG_EMERG=0
LOG_ALERT=1
LOG_CRIT=2
LOG_ERR=3
LOG_WARNING=4
LOG_NOTICE=5
LOG_INFO=6
LOG_DEBUG=7

g_log_level=${LOG_INFO}

SUPPORTED_PKG_FORMAT=1

## Exit status codes:
SC_OK=0       ## Success
SC_ERR=1      ## Generic error
SC_ERR_NET=2  ## Network failure

g_sc=${SC_ERR} ## Prime with a generic error.

on_exit()
{
    return ${g_sc}
}

print_help_and_exit()
{
    cat <<'EOF'
Usage: puavo-pkg [OPTIONS] [COMMAND] [COMMAND_ARGS]

Package manager for Puavo packages.

Options:
  -h, --help                     print this help and exit
  -q, --quiet                    less verbose output, can be given
                                 multiple times to silence puavo-pkg

Commands:
  gc-installations               garbage collect puavo-pkg installations
  gc-upstream-packs              garbage collect upstream packs

  install INSTALLER              install package with an installer

  license INSTALLER|PACKAGE      print license URL

  list                           list installed packages

  reconfigure PACKAGE            reconfigure installed PACKAGE
  reconfigure --all              reconfigure all installed packages

  remove PACKAGE                 remove installed PACKAGE
  remove --all                   remove all installed packages

  show INSTALLER|PACKAGE         show package details
  show -F|--field FIELD PACKAGE  show specific FIELD

Files:
  /etc/puavo-pkg/puavo-pkg.conf  configuration file

Exit status codes:
  0 - Success
  1 - Generic error
  2 - Network failure
EOF
    g_sc=${SC_OK}
    exit 0
}

log_error()
{
    if [ ${g_log_level} -ge ${LOG_ERR} ]; then
        echo "ERROR: $@" >&2
    fi
}

log_info()
{
    if [ ${g_log_level} -ge ${LOG_INFO} ]; then
        echo "INFO: $@" >&2
    fi
}

log_warning()
{
    if [ ${g_log_level} -ge ${LOG_WARNING} ]; then
        echo "WARNING: $@" >&2
    fi
}

gc_installations() {
    local gc_status installed_pkg_version msg pkg_installation pkg_version \
          root_basedir

    gc_status=$SC_OK

    for root_basedir in "${g_puavo_pkg_rootdir}"/packages/*; do
        installed_pkg_version="$(readlink "${root_basedir}/installed")" || true

        for pkg_installation in "$root_basedir"/*; do
            pkg_version="$(basename "$pkg_installation")"
            [ "$pkg_version" != 'installed' ] || continue
            [ -d "$pkg_installation"        ] || continue

            if [ "$installed_pkg_version" != "$pkg_version" ]; then
                if rm -rf "$pkg_installation"; then
                    log_info "removed old installation in $pkg_installation"
                else
                    msg="could not remove old installation in $pkg_installation"
                    log_error "$msg"
                    gc_status=$SC_ERR
                fi
            fi
        done

        rmdir --ignore-fail-on-non-empty "$root_basedir" 2>/dev/null || true
    done

    if [ "$gc_status" = "$SC_ERR" ]; then
      g_sc=$gc_status
      return 1
    fi

    return 0
}

gc_upstream_packs() {
    local cache_subdir gc_status old_upstream_pack old_upstream_pack_list \
          upstream_pack_path

    [ -n "$g_puavo_pkg_cachedir" ] || return 0

    gc_status=$SC_OK

    for cache_subdir in "$g_puavo_pkg_cachedir"/upstream_packs/*; do
        old_upstream_pack_list=$(ls -1t "$cache_subdir" | sed -n '2,$p')
        for old_upstream_pack in $old_upstream_pack_list; do
            upstream_pack_path="${cache_subdir}/${old_upstream_pack}"
            if rm -f "${upstream_pack_path}"; then
                log_info "removed old pack ${upstream_pack_path} from cache"
            else
                log_error "error removing ${upstream_pack_path} from cache"
                gc_status=$SC_ERR
            fi
        done
    done

    if [ "$gc_status" = "$SC_ERR" ]; then
      g_sc=$gc_status
      return 1
    fi

    return 0
}

list_installed_pkg_dirs()
{
    find "${g_puavo_pkg_rootdir}/packages" \
        -maxdepth 2                        \
        -mindepth 2                        \
        -type l                            \
        -name installed                    \
        -exec readlink -z -e {} \; | sort -z
}

list_installed_pkgs()
{
    local pkg_dir pkg_name

    while read -d '' pkg_dir; do
        pkg_name=$(get_pkg_name "${pkg_dir}") || return 1
        echo "${pkg_name}" || return 1
    done < <(list_installed_pkg_dirs)
}

list_installed_pkgs_with_versions()
{
    local pkg_dir pkg_name pkg_version col1_len

    col1_len=$(awk 'BEGIN { max = 0 }
                          { max = (length($0) > max) ? length($0) : max }
                    END   { print max }' < <(list_installed_pkgs)) || return 1

    while read -d '' pkg_dir; do
        pkg_name=$(get_pkg_name "${pkg_dir}") || return 1
        pkg_version=$(get_pkg_version "${pkg_dir}") || return 1
        printf "%-${col1_len}s %s\n" "${pkg_name}" "${pkg_version}"
    done < <(list_installed_pkg_dirs)
}

get_license_url()
{
    local identifier INSTALLER_REGEX pkg_dir

    identifier=$1
    INSTALLER_REGEX='\.tar\.gz$'

    if [[ "${identifier}" =~ ${INSTALLER_REGEX} ]]; then
        pkg_dir=$(extract_installer "${identifier}") || {
            log_error "failed to extract installer '${identifier}'"
            return 1
        }
    else
        pkg_dir=$(get_installed_pkg_dir "${identifier}") || return 1
    fi

    [ -f "${pkg_dir}/license" ] && echo "file://${pkg_dir}/license"
}

get_pkg_basedir()
{
    echo "${g_puavo_pkg_rootdir}/packages/$1"
}

get_pkg_link()
{
    local pkg_name pkg_basedir

    pkg_name=$1
    pkg_basedir=$(get_pkg_basedir "${pkg_name}") || return 1

    echo "${pkg_basedir}/installed"
}

get_pkg_dir()
{
    local pkg_name pkg_version pkg_basedir

    pkg_name=$1
    pkg_version=$2
    pkg_basedir=$(get_pkg_basedir "${pkg_name}") || return 1

    echo "${pkg_basedir}/${pkg_version}"
}

get_installed_pkg_dir()
{
    local pkg_name pkg_link

    pkg_name=$1
    pkg_link=$(get_pkg_link "${pkg_name}") || return 1

    readlink -e "${pkg_link}" || true
}

get_installed_pkg_version()
{
    local pkg_name pkg_dir

    pkg_name=$1
    pkg_dir=$(get_installed_pkg_dir "${pkg_name}") || return 1

    [ -n "${pkg_dir}" ] || return 0

    basename "${pkg_dir}"
}

get_pkg_name()
{
    local pkg_dir pkg_basedir

    pkg_dir=$1
    pkg_basedir=$(dirname "${pkg_dir}") || return 1

    basename "${pkg_basedir}"
}

get_pkg_version()
{
    basename "$1"
}

configure_pkg()
{
    local pkg_name pkg_version pkg_dir upstream_dir installed_pkg_dir pkg_link

    pkg_name=$1
    pkg_version=$2
    pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}") || return 1
    upstream_dir="${pkg_dir}/upstream"
    installed_pkg_dir=$(get_installed_pkg_dir "${pkg_name}") || return 1
    pkg_link=$(get_pkg_link "${pkg_name}") || return 1

    if [ -n "${installed_pkg_dir}" ]; then
        if [ "${installed_pkg_dir}" != "${pkg_dir}" ]; then
            log_error "another version of the package has already been " \
                "configured, unconfigure it before proceeding"
            return 1
        fi
    fi

    pushd "${pkg_dir}" >/dev/null || return 1
    ./rules configure "${upstream_dir}" || {
        popd >/dev/null || true
        log_error "failed to configure package '${pkg_name}'"
        return 1
    }
    popd >/dev/null || return 1

    ln -fns "${pkg_version}" "${pkg_link}" || {
        log_error "failed to create a package link"
        return 1
    }

    log_info "${pkg_name}: configured successfully" || true
}

reconfigure_pkg()
{
    local pkg_name pkg_version

    pkg_name=$1
    pkg_version=$(get_installed_pkg_version "${pkg_name}") || return 1

    configure_pkg "${pkg_name}" "${pkg_version}"
}

reconfigure_all_pkgs()
{
    local pkg pkgs retval

    pkgs=$(list_installed_pkgs) || return 1
    retval=0

    for pkg in ${pkgs}; do
        reconfigure_pkg "${pkg}" || retval=1
    done

    return ${retval}
}

unconfigure_pkg()
{
    local pkg_name pkg_link pkg_dir upstream_dir pkg_version

    pkg_name=$1
    pkg_version=$2

    pkg_link=$(get_pkg_link "${pkg_name}") || return 1
    pkg_dir=$(readlink -e "${pkg_link}") || true
    upstream_dir="${pkg_dir}/upstream"

    [ -n "${pkg_dir}" ] || return 0

    pushd "${pkg_dir}" >/dev/null || return 1
    ./rules unconfigure "${upstream_dir}" >/dev/null || {
        popd >/dev/null || true
        log_error "failed to unconfigure package '${pkg_name}'"
        return 1
    }
    popd >/dev/null || return 1

    rm -f "${pkg_link}" || return 1

    log_info "${pkg_name}: unconfigured successfully"
}

unpack_upstream_pack()
{
    local pkg_name pkg_version pkg_dir upstream_pack upstream_dir upstream_tmpdir

    pkg_name=$1
    pkg_version=$2
    pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}") || return 1
    upstream_pack="${pkg_dir}/upstream_pack"
    upstream_dir="${pkg_dir}/upstream"
    upstream_tmpdir="${upstream_dir}.tmp"

    if [ -d "${upstream_dir}" ]; then
        return 0
    fi

    check_md5sum "${pkg_dir}/upstream_pack_md5sum" "${upstream_pack}" || {
        log_error "upstream pack has incorrect checksum, " \
            "perhaps you should purge the package and download it again?"
        return 1
    }

    rm -rf "${upstream_tmpdir}"
    mkdir "${upstream_tmpdir}" || return 1

    pushd "${pkg_dir}" >/dev/null || return 1
    ./rules unpack "${upstream_pack}" "${upstream_tmpdir}" || {
        popd >/dev/null || true
        rm -rf "${upstream_tmpdir}"
        return 1
    }
    popd >/dev/null || {
        rm -rf "${upstream_tmpdir}"
        return 1
    }

    mv -T "${upstream_tmpdir}" "${upstream_dir}" || {
        rm -rf "${upstream_tmpdir}"
        return 1
    }

    ## Remove the upstream pack, it is not needed anymore since we just
    ## unpacked it successfully.
    rm -f "${upstream_pack}"

    log_info "${pkg_name}: unpacked upstream pack successfully"
}

check_md5sum()
{
    local md5sum_file file actual_md5sum_str expected_md5sum_str

    md5sum_file=$1
    file=$2

    [ -r "${file}" ] || return 1

    [ -r "${md5sum_file}" ] || return 0
    expected_md5sum_str=$(cat "${md5sum_file}") || return 1

    actual_md5sum_str=$(md5sum "${file}" 2>/dev/null | awk '{ print $1 }')

    [ -n "$actual_md5sum_str"   ] || return 1
    [ -n "$expected_md5sum_str" ] || return 1

    if [ "$actual_md5sum_str" != "$expected_md5sum_str" ]; then
        log_error "expected checksum '${expected_md5sum_str}' in '${file}'," \
                  "yet actual checksum is '${actual_md5sum_str}'"
        return 1
    fi

    return 0
}

cache_load_upstream_pack()
{
    local pkg_name pkg_version pkg_dir upstream_pack md5sum_file md5sum_str cached_upstream_pack

    pkg_name=$1
    pkg_version=$2

    [ -n "${g_puavo_pkg_cachedir}" ] || return 0

    pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}") || return 1
    upstream_pack="${pkg_dir}/upstream_pack"
    md5sum_file="${pkg_dir}/upstream_pack_md5sum"

    [ -r "${md5sum_file}"  ] || return 0
    md5sum_str=$(cat "${md5sum_file}") || return 1

    [ -n "${md5sum_str}" ] || return 0

    cached_upstream_pack="${g_puavo_pkg_cachedir}/upstream_packs/${pkg_name}/${md5sum_str}"
    if [ -r "${cached_upstream_pack}" ]; then
        cp -a -T "${cached_upstream_pack}" "${upstream_pack}" || return 1
        log_info "${pkg_name}: loaded upstream pack from the cache successfully"
    fi
}

cache_save_upstream_pack()
{
    local pkg_name pkg_version pkg_dir upstream_pack md5sum_str

    pkg_name=$1
    pkg_version=$2

    [ -n "${g_puavo_pkg_cachedir}" ] || return 0

    pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}") || return 1
    upstream_pack="${pkg_dir}/upstream_pack"
    md5sum_str=$(md5sum "${upstream_pack}" | cut -d' ' -f1)

    if [ -n "${md5sum_str}" ]; then
        mkdir -p "${g_puavo_pkg_cachedir}/upstream_packs/${pkg_name}"
        cp -a -T "${upstream_pack}" "${g_puavo_pkg_cachedir}/upstream_packs/${pkg_name}/${md5sum_str}" || return 1
    fi

    log_info "${pkg_name}: saved upstream pack to cache successfully"
}

download_upstream_pack()
{
    local pkg_name pkg_version pkg_dir upstream_pack upstream_tmppack

    pkg_name=$1
    pkg_version=$2
    pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}") || return 1
    upstream_pack="${pkg_dir}/upstream_pack"
    upstream_tmppack="${upstream_pack}.tmp"

    cache_load_upstream_pack "${pkg_name}" "${pkg_version}" || {
        log_warning "${pkg_name}: failed to load the upstream pack from the cache"
    }

    if check_md5sum "${pkg_dir}/upstream_pack_md5sum" "${upstream_pack}"; then
        return 0
    fi

    if [ ! -r "${pkg_dir}/upstream_pack_url" ]; then
        pushd "${pkg_dir}" >/dev/null || return 1
        ./rules download "${upstream_tmppack}" || {
            [ $? -eq 2 ] && g_sc=${SC_ERR_NET}
            popd >/dev/null || true
            rm -rf "${upstream_tmppack}" || true
            log_error "package downloader returned an error!"
            return 1
        }
        popd >/dev/null || {
            rm -rf "${upstream_tmppack}"
            return 1
        }
    else
        wget \
            --no-use-server-timestamps \
            --no-check-certificate \
            --no-cookies \
            --input-file "${pkg_dir}/upstream_pack_url" \
            --output-document "${upstream_tmppack}" \
            --progress=dot:mega || {
            [ $? -eq 4 ] && g_sc=${SC_ERR_NET}
            rm -rf "${upstream_tmppack}"
            return 1
        }
    fi

    check_md5sum "${pkg_dir}/upstream_pack_md5sum" "${upstream_tmppack}" || {
        log_error "downloaded upstream pack has incorrect checksum"
        rm -rf "${upstream_tmppack}"
        return 1
    }

    mv -T "${upstream_tmppack}" "${upstream_pack}" || {
        rm -rf "${upstream_pack}"
        return 1
    }

    cache_save_upstream_pack "${pkg_name}" "${pkg_version}" || {
        log_warning "${pkg_name}: failed to save upstream pack to the cache"
    }

    log_info "${pkg_name}: downloaded upstream pack successfully"
}

get_md5sum()
{
    local file output

    file=$1
    output=$(md5sum "${file}") || return 1

    awk '{print $1}' <<<"${output}"
}

extract_installer()
{
    local installer pkg_name pkg_version pkg_dir pkg_tmpdir pkg_format

    installer=$1
    pkg_name=$(basename "${installer}" .tar.gz) || return 1

    if [ ! -f "${installer}" ]; then
        log_error "installer '${installer}' does not exist"
        return 1
    fi

    pkg_version=$(get_md5sum "${installer}") || return 1

    pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}")
    pkg_tmpdir="${pkg_dir}.tmp"

    if [ -d "${pkg_dir}" ]; then
        echo "${pkg_dir}"
        return
    fi

    mkdir -p "${pkg_tmpdir}" || return 1

    tar --no-same-owner --no-same-permissions --strip-components=1 \
        -z -x -f "${installer}" -C "${pkg_tmpdir}"  || {
        rm -rf "${pkg_tmpdir}"
        return 1
    }

    ## Format file is optional in package format 1.
    pkg_format=1
    if [ -f "${pkg_tmpdir}/format" ]; then
        pkg_format=$(cat "${pkg_tmpdir}/format") || {
            log_error "failed to read installer format"
            rm -rf "${pkg_tmpdir}"
            return 1
        }
    fi

    if [ "${pkg_format}" != "${SUPPORTED_PKG_FORMAT}" ]; then
        log_error "installer has unsupported format"
        rm -rf "${pkg_tmpdir}"
        return 1
    fi

    mv -T "${pkg_tmpdir}" "${pkg_dir}" || {
        rm -rf "${pkg_tmpdir}"
        return 1
    }

    log_info "${pkg_name}: extracted installer file successfully"

    echo "${pkg_dir}"
}

install_pkg_with_installer()
{
    local installer pkg_dir pkg_name pkg_version old_pkg_version old_pkg_dir

    installer=$1
    pkg_dir=$(extract_installer "${installer}") || {
        log_error "failed to extract '${installer}'"
        return 1
    }

    pkg_name=$(get_pkg_name "${pkg_dir}") || return 1
    pkg_version=$(get_pkg_version "${pkg_dir}") || return 1

    download_upstream_pack "${pkg_name}" "${pkg_version}" || {
        log_error "failed to download the upstream pack of package '${pkg_name}'"
        return 1
    }

    unpack_upstream_pack "${pkg_name}" "${pkg_version}" || {
        log_error "failed to unpack the upstream pack of package '${pkg_name}'"
        return 1
    }

    old_pkg_version=$(get_installed_pkg_version "${pkg_name}") || return 1
    if [ -n "${old_pkg_version}" -a "${old_pkg_version}" != "${pkg_version}" ]; then
        unconfigure_pkg "${pkg_name}" "${old_pkg_version}" || {
            log_error "failed to unconfigure package '${pkg_name}'"
            return 1
        }
    fi

    configure_pkg "${pkg_name}" "${pkg_version}" || {
        log_error "${pkg_name}: failed to configure package version '${pkg_version}'"
        if [ -n "${old_pkg_version}" -a "${old_pkg_version}" != "${pkg_version}" ]; then
            configure_pkg "${pkg_name}" "${old_pkg_version}" || {
                log_error "${pkg_name}: failed to reconfigure the previous version '${old_pkg_version}'"
                return 1
            }
            log_info "${pkg_name}: reconfigured the previous version '${old_pkg_version}' successfully"
        fi
        return 1
    }

    if [ -n "${old_pkg_version}" -a "${old_pkg_version}" != "${pkg_version}" ]; then
        old_pkg_dir=$(get_pkg_dir "${pkg_name}" "${old_pkg_version}") \
            && rm -rf "${old_pkg_dir}" || true
    fi

    log_info "${pkg_name}: installed successfully"
}

remove_pkg()
{
    local pkg_name pkg_dir pkg_version

    pkg_name=$1

    pkg_version=$(get_installed_pkg_version "${pkg_name}") || return 1
    if [ -n "${pkg_version}" ]; then
        unconfigure_pkg "${pkg_name}" "${pkg_version}" || {
            log_error "failed to unconfigure package '${pkg_name}'"
            return 1
        }
        pkg_dir=$(get_pkg_dir "${pkg_name}" "${pkg_version}") || return 1
        rm -rf "${pkg_dir}" || return 1
        log_info "removed package '${pkg_name}'"
        return 0
    fi

    log_error "package '${pkg_name}' is not installed"
    return 1
}

remove_all_pkgs()
{
    local pkg pkgs retval

    pkgs=$(list_installed_pkgs) || return 1
    retval=0

    for pkg in ${pkgs}; do
        remove_pkg "${pkg}" || retval=1
    done

    return ${retval}
}

show_pkg()
{
    local pkg_name pkg_dir pkg_version pkg_legend pkg_description pkg_field identifier INSTALLER_REGEX

    identifier=$1
    pkg_field=$2

    INSTALLER_REGEX='\.tar\.gz$'

    if [[ "${identifier}" =~ ${INSTALLER_REGEX} ]]; then
        pkg_dir=$(extract_installer "${identifier}") || {
            log_error "failed to extract installer '${identifier}'"
            return 1
        }
    else
        pkg_dir=$(get_installed_pkg_dir "${identifier}") || return 1
    fi

    pkg_name=$(get_pkg_name "${pkg_dir}") || return 1
    pkg_version=$(get_pkg_version "${pkg_dir}") || return 1
    if [ -z "${pkg_version}" ]; then
        log_error "package ${pkg_name} is not installed"
        return 1
    fi

    pkg_legend="${pkg_name}"
    if [ -r "${pkg_dir}/legend" ]; then
        pkg_legend=$(head -n1 "${pkg_dir}/legend") || return 1
    fi

    pkg_description=
    if [ -r "${pkg_dir}/description" ]; then
        pkg_description=$(cat "${pkg_dir}/description") || return 1
    fi

    case "${pkg_field}" in
        Name)
            echo "${pkg_name}"
            ;;
        Version)
            echo "${pkg_version}"
            ;;
        Directory)
            echo "${pkg_dir}"
            ;;
        Legend)
            echo "${pkg_legend}"
            ;;
        Description)
            echo "${pkg_description}"
            ;;
        '')
            echo "Name: ${pkg_name}"
            echo "Version: ${pkg_version}"
            echo "Directory: ${pkg_dir}"
            echo "Legend: ${pkg_legend}"
            echo "Description:"
            if [ -n "${pkg_description}" ]; then
                echo "${pkg_description}" | sed -r -e 's/^\s*$/./' -e 's/(.*)/ \1/'
                echo ' .'
            fi
            ;;
        *)
            log_error "unknown field '${pkg_field}'"
            return 1
            ;;
    esac
}

usage_error()
{
    log_error "$1"
    echo "Try 'puavo-pkg --help' for more information." >&2
    return 1
}

assert_args_count()
{
    local op count

    op=$1
    count=$2
    shift 2

    if [ ! $# ${op} "${count}" ]; then
        usage_error "invalid number of arguments ($#), expected ${count}"
        return
    fi
}

## Main begins.

set -eu

trap on_exit EXIT

while [ $# -gt 0 ]; do
    case $1 in
        -h|--help)
            shift
            print_help_and_exit
            ;;
        -q|--quiet)
            shift
            if [ ${g_log_level} -gt 0 ]; then
                g_log_level=$((g_log_level - 1))
            fi
            ;;
        --)
            shift
            break
            ;;
        -*)
            usage_error "invalid argument '$1'"
            ;;
        *)
            break
            ;;
    esac
done

if [ $# -lt 1 ]; then
    print_help_and_exit
fi

## Override default configuration with values from the config file.
if [ -r /etc/puavo-pkg/puavo-pkg.conf ]; then
    . /etc/puavo-pkg/puavo-pkg.conf
    if [ ! -z ${PUAVO_PKG_ROOTDIR+x} ]; then
        g_puavo_pkg_rootdir="${PUAVO_PKG_ROOTDIR}"
    fi
    if [ ! -z ${PUAVO_PKG_CACHEDIR+x} ]; then
        g_puavo_pkg_cachedir="${PUAVO_PKG_CACHEDIR}"
    fi
fi

## Validate configuration.
[[ "${g_puavo_pkg_rootdir}" =~ ^/ ]] || usage_error "invalid root dir path"

mkdir -p "${g_puavo_pkg_rootdir}/packages"

command=$1
shift

case "${command}" in
    gc-installations)
        assert_args_count -eq 0 "$@"
        gc_installations
        ;;
    gc-upstream-packs)
        assert_args_count -eq 0 "$@"
        gc_upstream_packs
        ;;
    install)
        assert_args_count -eq 1 "$@"
        install_pkg_with_installer "$1"
        ;;
    license)
        assert_args_count -eq 1 "$@"
        get_license_url "$1"
        ;;
    list)
        assert_args_count -eq 0 "$@"
        list_installed_pkgs_with_versions
        ;;
    reconfigure)
        assert_args_count -eq 1 "$@"
        if [ "$1" = '--all' ]; then
            reconfigure_all_pkgs
        else
            reconfigure_pkg "$1"
        fi
        ;;
    remove)
        assert_args_count -eq 1 "$@"
        if [ "$1" = '--all' ]; then
            remove_all_pkgs
        else
            remove_pkg "$1"
        fi
        ;;
    show)
        assert_args_count -ge 1 "$@"
        case "$1" in
            -F|--field)
                shift
                assert_args_count -eq 2 "$@"
                show_pkg "$2" "$1"
                ;;
            *)
                assert_args_count -eq 1 "$@"
                show_pkg "$1" ""
                ;;
        esac
        ;;
    *)
        usage_error "unknown command '${command}'"
esac

g_sc=${SC_OK}
exit 0