manof.py

import argparse
import sys

from twisted.internet import reactor

import core
import clients.logging


def _run(args, known_arg_options):
    retval = 1

    logger = clients.logging.Client(
        "manof",
        initial_severity=args.log_severity,
        initial_console_severity=args.log_console_severity,
        initial_file_severity=args.log_file_severity,
        output_stdout=not args.log_disable_stdout,
        output_dir=args.log_output_dir,
        max_log_size_mb=args.log_file_rotate_max_file_size,
        max_num_log_files=args.log_file_rotate_num_files,
        log_file_name=args.log_file_name,
        log_colors=args.log_colors,
    ).logger

    # start root logger with kwargs and create manof
    manof_instance = core.Manof(logger, args, known_arg_options)

    d = manof_instance.execute_command()

    # after run and possibly re-run, stop the reactor
    d.addBoth(lambda _: reactor.callFromThread(reactor.stop))

    reactor.run()

    if logger.first_error is None:
        retval = 0

    return retval


def _register_arguments(parser):

    # main command subparser, to which we'll add subparsers below
    subparsers = parser.add_subparsers(
        dest="command",
        title="subcommands",
        description=(
            "To print additional help on a subcommand, run manof <subcmd> --help"
        ),
    )

    # global options for manof
    clients.logging.Client.register_arguments(parser)

    parser.add_argument(
        "-mp", "--manofest-path", help="Location of manofest.py", default="manofest.py"
    )

    parser.add_argument(
        "--num-retries",
        help="Set number of retires for push and pull operations after first try fails",
        type=int,
        default=2,
    )

    # don't actually run any commands
    parser.add_argument(
        "-dr",
        "--dry-run",
        help="Don't actually run any commands, just log",
        action="store_true",
    )

    parser.add_argument(
        "-p",
        "--parallel",
        action="store",
        help="Set how many commands to run in parallel",
        type=int,
    )

    # update
    subparsers.add_parser("update", help="Updates Manof")

    # base sub parser
    base_command_parent_parser = argparse.ArgumentParser(add_help=False)
    base_command_parent_parser.add_argument("targets", nargs="+")
    base_command_parent_parser.add_argument(
        "-e",
        "--exclude",
        help="Exclude targets when running manof cmd (comma-delimited, no spaces)",
        default="",
    )

    # TODO: Change default to 'docker.io'. Currently default is None for backwards compatibility
    base_command_parent_parser.add_argument(
        "-r",
        "--repository",
        help="The repository from which images shall be taken from or pushed to",
        default=None,
    )

    # image based commands
    provision_parent_command = argparse.ArgumentParser(add_help=False)
    provision_parent_command.add_argument(
        "-n", "--no-cache", help="Don't use cache images on build", action="store_true"
    )
    provision_parent_command.add_argument(
        "--force-rm",
        help=(
            "Image: Always remove intermediate containers. "
            "NamedVolume: Delete existing before creation"
        ),
        action="store_true",
    )
    provision_parent_command.add_argument(
        "-tl",
        "--skip-tag-local",
        help=(
            "If no context is given, provision will perform pull and "
            "skip tagging the image with its local repository (default: False)"
        ),
        dest="tag_local",
        action="store_false",
    )

    # provision
    subparsers.add_parser(
        "provision",
        help="Build or pull target images",
        parents=[base_command_parent_parser, provision_parent_command],
    )

    run_parent_parser = argparse.ArgumentParser(add_help=False)
    run_parent_parser.add_argument(
        "--privileged",
        action="store_true",
        help="Give extended privileges to these containers",
    )
    run_parent_parser.add_argument(
        "--device",
        help="Add a host device to the containers (can be used multiple times)",
        action="append",
        dest="devices",
    )
    run_parent_parser.add_argument(
        "--device-cgroup-rule",
        help="Add a rule to the cgroup allowed devices list (e.g. c 42:* rmw)",
    )
    run_parent_parser.add_argument(
        "--device-read-bps",
        help="Limit read rate (bytes per second) from a device (e.g. /dev/sda:50mb)",
    )
    run_parent_parser.add_argument(
        "--device-read-iops",
        help="Limit read rate (IO per second) from a device (e.g. /dev/sda:50)",
    )
    run_parent_parser.add_argument(
        "--device-write-bps",
        help="Limit write rate (bytes per second) to a device (e.g. /dev/sda:50mb)",
    )
    run_parent_parser.add_argument(
        "--device-write-iops",
        help="Limit write rate (IO per second) to a device (e.g. /dev/sda:50)",
    )
    run_parent_parser.add_argument(
        "--cap-add", help="Add capability to the container", action="append"
    )
    run_parent_parser.add_argument(
        "--cap-drop", help="Drop capability from the container", action="append"
    )
    run_parent_parser.add_argument(
        "-dv",
        "--delete-volumes",
        help="Image: Delete named_volumes that are used by this image",
        action="store_true",
    )
    run_parent_parser.add_argument(
        "-pco",
        "--print-command-only",
        help="Will enforce dry run and print the run command only, no logs at all",
        action="store_true",
    )
    run_parent_parser.add_argument(
        "-prmd5o",
        "--print-run-md5-only",
        help="Will print the run command md5 only. no logs at all",
        action="store_true",
    )

    # run
    subparsers.add_parser(
        "run",
        help="Run target containers",
        parents=[base_command_parent_parser, run_parent_parser],
    )

    # stop
    stop_command = subparsers.add_parser(
        "stop", help="Stop target containers", parents=[base_command_parent_parser]
    )
    stop_command.add_argument(
        "-t",
        "--time",
        help="Seconds to wait for stop before killing it (default=10)",
        type=int,
        default=10,
    )

    # rm
    rm_command = subparsers.add_parser(
        "rm", help="Remove targets", parents=[base_command_parent_parser]
    )
    rm_command.add_argument(
        "-f",
        "--force",
        help="Kill targets even if they are running",
        action="store_true",
    )
    rm_command.add_argument(
        "-v",
        "--volumes",
        help="Remove the volumes associated with the container",
        action="store_true",
    )

    # serialize
    subparsers.add_parser(
        "serialize",
        help="Get a JSON representation of the targets",
        parents=[base_command_parent_parser],
    )

    # push
    push_command = subparsers.add_parser(
        "push", help="Push targets", parents=[base_command_parent_parser]
    )
    push_command.add_argument(
        "-nc",
        "--no-cleanup",
        help="After pushing, delete the tagged image created to push",
        action="store_true",
    )

    # pull
    pull_parent_parser = argparse.ArgumentParser(add_help=False)
    pull_parent_parser.add_argument(
        "-tl",
        "--tag-local",
        help="After pulling, tag the image with its local repository",
        action="store_true",
    )
    subparsers.add_parser(
        "pull",
        help="Pull targets",
        parents=[base_command_parent_parser, pull_parent_parser],
    )

    # lift
    subparsers.add_parser(
        "lift",
        help="Provision and run targets",
        parents=[
            base_command_parent_parser,
            provision_parent_command,
            run_parent_parser,
        ],
    )

    known_option_strings = list(parser._option_string_actions.keys())

    for subparser in subparsers.choices.values():
        known_option_strings += list(subparser._option_string_actions.keys())

    # unique
    return set(known_option_strings)


def run():

    # create an argument parser
    ap = argparse.ArgumentParser()

    # register all arguments and sub-commands
    known_option_strings = _register_arguments(ap)

    # parse the known args, seeing how the targets may add arguments of their own and re-parse
    retval = _run(ap.parse_known_args()[0], known_option_strings)

    # return value
    return retval


if __name__ == "__main__":
    sys.exit(run())