webis.py

#!/usr/bin/env python3
"""The main webis command.

Copyright webis.de 2015-today
Authors: Steve Göring, Martin Potthast
"""

import argparse
import collections
import json
import os
import sys

import loader

from lib import *
from log import *
from system import *


def load_config():
    """Returns the configuration, based on the JSON configuration file."""
    try:
        return json.loads(read_file(os.path.dirname(
            os.path.realpath(__file__)) + "/config.json"))
    except Exception as e:
        lError("The file config.json is invalid.")
        sys.exit(1)


def get_commands(config):
    """Returns commands mapped to directories containing their subcommands."""
    commands = collections.OrderedDict()
    for directory in os.listdir(config["commands_directory"]):
        if (os.path.isdir(config["commands_directory"] + directory) and
                directory not in config["ignored_dirs"]):
            commands[directory] = config["commands_directory"] + directory
    return commands


def get_subcommands(config, commandpath):
    """Returns subcommands of a given command mapped to their script files."""
    subcommands = collections.OrderedDict()
    for script in os.listdir(commandpath):
        subcommandpath = commandpath + "/" + script
        if os.path.isfile(subcommandpath):
            allowed_scripts = config["allowed_scripts"]
            if check_subcommand_shebang(subcommandpath, allowed_scripts):
                subcommand = script.rsplit(".", 1)[0]
                subcommands[subcommand] = subcommandpath
    return subcommands


def get_subcommand_help(subcommandpath):
    """Returns the help message expected at the beginning of a command."""
    if not os.path.isfile(subcommandpath):
        return os.path.basename(subcommandpath)

    f = open(subcommandpath)
    lines = f.readlines()
    f.close()
    if len(lines) < 1 or lines[1][0] != "#":
        return ""
    return lines[1][1:].replace("\n", "").strip()


def check_subcommand_shebang(subcommandpath, allowed_scripts):
    """Checks if the shebang of a given script is among the allowed shebangs."""
    shebang = get_shebang(subcommandpath)
    for interpreter in allowed_scripts:
        if interpreter in shebang:
            return True
    return False


def run_subcommand(subcommand, subcommandpath, params=[]):
    """Runs subcommand passing params and returns its exit code."""
    lDbg("Running " + subcommand + " at " + subcommandpath)
    # FIXME: When the script is installed at /usr/lib, this won't work, anymore:
    os.system("chmod +x {}".format(subcommandpath))
    cmd = " ".join([subcommandpath] + params)
    return_value = os.system(cmd)
    if return_value == 0:
        lInfo("Done.")
    else:
        lError("An error occurred while executing " + cmd)
    return return_value


def main(args):
    config = load_config()
    commands = get_commands(config)
    parser = argparse.ArgumentParser()
    subparsers = {}
    allcommands = {}
    commandparsers = parser.add_subparsers(
        metavar='<command>', dest='<command>', help='Available commands:')
    for command in commands:
        # TODO: It is unclear where to obtain the help messages for commands.
        # TODO: It is conceivable to introduce aliases for each command, but it
        # is unclear where to obtain them. Simply using a prefix does not
        # work for betamng and betaweb, since they share a long prefix.
        commandparser = commandparsers.add_parser(
            command, help='TODO: Help message for commands.')
        subparsers[command] = commandparser
        subcommandparsers = commandparser.add_subparsers(
            metavar='<subcommand>', dest='<subcommand>',
            help='Available subcommands:')
        subcommands = get_subcommands(config, commands[command])
        allcommands[command] = subcommands
        for subcommand in subcommands:
            subcommandparser = subcommandparsers.add_parser(
                subcommand, help=str(
                    get_subcommand_help(subcommands[subcommand])),
                add_help=False)
            subparsers[subcommand] = subcommandparser

    if len(args) == 0:
        parser.print_help()
        return 0

    parseresults = parser.parse_known_args(args)
    argsdict = vars(parseresults[0])
    parameter = parseresults[1]

    if len(argsdict) == 2 and argsdict['<subcommand>'] is None:
        subparsers[argsdict['<command>']].print_help()
        return 0

    return run_subcommand(
        argsdict['<subcommand>'],
        allcommands[argsdict['<command>']][argsdict['<subcommand>']],
        parameter)


if __name__ == "__main__":
    sys.exit(main(sys.argv[1:]))