Example #1
0
def main(args=None):
        """The main routine."""
        if args is None:
                args = sys.argv[1:]

        parser = argparse.ArgumentParser(description="Kinto commands")
        subparsers = parser.add_subparsers(title='subcommands',
                                           description='valid subcommands',
                                           help='init/start/migrate')

        parser_init = subparsers.add_parser('init')
        parser_init.set_defaults(which='init')
        parser_init.add_argument('--config_file', required=False,
                                 help='Config file may be passed as argument')

        parser_migrate = subparsers.add_parser('migrate')
        parser_migrate.set_defaults(which='migrate')

        parser_start = subparsers.add_parser('start')
        parser_start.set_defaults(which='start')

        args = vars(parser.parse_args())

        if args['which'] == 'init':
                if(args['config_file'] is None):
                    env = bootstrap('config/kinto.ini')
                else:
                    config_file = format(args['config_file'])
                    env = bootstrap(config_file)
        elif args['which'] == 'migrate':
                env = bootstrap('config/kinto.ini')
                cliquet.init_schema(env)
        elif args['which'] == 'start':
                pserve_argv = ['pserve', 'config/kinto.ini', '--reload']
                pserve.main(pserve_argv)
Example #2
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto commands")
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=CONFIG_FILE)
    parser.add_argument('--backend',
                        help='Specify backend',
                        dest='backend',
                        required=False,
                        default=None)

    subparsers = parser.add_subparsers(title='subcommands',
                                       description='valid subcommands',
                                       help='init/start/migrate')

    parser_init = subparsers.add_parser('init')
    parser_init.set_defaults(which='init')

    parser_migrate = subparsers.add_parser('migrate')
    parser_migrate.set_defaults(which='migrate')

    parser_start = subparsers.add_parser('start')
    parser_start.set_defaults(which='start')

    args = vars(parser.parse_args())
    config_file = args['ini_file']

    if args['which'] == 'init':
        if os.path.exists(config_file):
            print("%s already exist." % config_file, file=sys.stderr)
            sys.exit(1)

        backend = args['backend']
        if not backend:
            while True:
                prompt = ("Which backend to use? "
                          "(1 - postgresql, 2 - redis, default - memory) ")
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend)

    elif args['which'] == 'migrate':
        env = bootstrap(config_file)
        cliquet.init_schema(env)

    elif args['which'] == 'start':
        pserve_argv = ['pserve', config_file, '--reload']
        pserve.main(pserve_argv)
Example #3
0
def start(args):
    """Start the server.

    With no arguments, starts the server in development mode using the
    configuration found in `deveopment.ini` and a hot code reloader enabled.
    """
    if not len(args):  # Default to dev mode
        pserve.ensure_port_cleanup([('0.0.0.0', 5000)])
        args.append('development.ini')
        args.append('--reload')

    pserve.main(['hypothesis'] + args)
Example #4
0
def start(args):
    """Start the server.

    With no arguments, starts the server in development mode using the
    configuration found in `deveopment.ini` and a hot code reloader enabled.
    """
    if not len(args):  # Default to dev mode
        pserve.ensure_port_cleanup([('0.0.0.0', 5000)])
        args.append('development.ini')
        args.append('--reload')

    pserve.main(['hypothesis'] + args)
Example #5
0
File: script.py Project: 3divs/h
def start(args):
    """Start the server.

    With no arguments, starts the server in development mode using the
    configuration found in `deveopment.ini` and a hot code reloader enabled.
    """
    if not len(args):  # Default to dev mode
        args.append('development.ini')
        args.append('--reload')
        args.append('--monitor-restart')

    from pyramid.scripts.pserve import ensure_port_cleanup, main

    ensure_port_cleanup([('0.0.0.0', 5000)])
    main(['hypothesis'] + args)
Example #6
0
def start(args):
    """Start the server.

    With no arguments, starts the server in development mode using the
    configuration found in `deveopment.ini` and a hot code reloader enabled.
    """
    if not len(args):  # Default to dev mode
        args.append('development.ini')
        args.append('--reload')
        args.append('--monitor-restart')

    from pyramid.scripts.pserve import ensure_port_cleanup, main

    ensure_port_cleanup([('0.0.0.0', 5000)])
    main(['hypothesis'] + args)
Example #7
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto commands")
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=CONFIG_FILE)

    subparsers = parser.add_subparsers(title='subcommands',
                                       description='valid subcommands',
                                       help='init/start/migrate')

    parser_init = subparsers.add_parser('init')
    parser_init.set_defaults(which='init')

    parser_migrate = subparsers.add_parser('migrate')
    parser_migrate.set_defaults(which='migrate')

    parser_start = subparsers.add_parser('start')
    parser_start.set_defaults(which='start')

    args = vars(parser.parse_args())
    config_file = args['ini_file']

    if args['which'] == 'init':
        if not os.path.exists(config_file):
            init(config_file)
        else:
            print("%s already exist." % config_file, file=sys.stderr)
            sys.exit(1)

    elif args['which'] == 'migrate':
        env = bootstrap(config_file)
        cliquet.init_schema(env)

    elif args['which'] == 'start':
        pserve_argv = ['pserve', config_file, '--reload']
        pserve.main(pserve_argv)
Example #8
0
def main(argv=sys.argv, quiet=False):
    opts = list(itertools.takewhile(lambda opt: opt.startswith('-'), argv[1:]))
    args = argv[1 + len(opts):]

    if not any(arg.endswith('.ini') for arg in args):
        args.insert(0, 'development.ini')
        if '--reload' not in opts:
            opts.append('--reload')

    if '--no-reload' in opts:
        opts.remove('--no-reload')
        try:
            opts.remove('--reload')
        except ValueError:
            pass

    pserve_args = ['pserve'] + opts + args
    print(*pserve_args)
    return pserve.main(pserve_args, quiet=quiet)
Example #9
0
def cmd_run(args):
    """

    :param dict args:
    :return:
    """
    yaml_config = args['<config>']
    with open(yaml_config, 'r') as configfile:
        pconf = yaml.load(configfile.read())

    conf = configparser.ConfigParser()
    conf.read_string(DEV_CONFIG)

    conf['app:main']['pacific.superuser_id'] = str(pconf['superuser_id'])

    # Databases
    # ------------------------------------
    db_settings = config_parser.parse_db_settings(pconf['db'])
    conf['app:main'].update(db_settings)

    # Applications
    # ------------------------------------
    apps = config_parser.parse_apps(pconf['apps'])
    conf['app:main'].update({'apps': apps})

    # Applications' templates
    template_dirs = [conf['app:main']['mako.directories']]
    template_dirs.extend(['{}:templates'.format(app) for app in pconf['apps']])
    template_dirs = ' '.join(template_dirs)
    conf['app:main'].update({'mako.directories': template_dirs})

    compiled_config = '.{}.pconf'.format(yaml_config)
    with open(compiled_config, 'w') as configfile:
        conf.write(configfile)

    pserve_argv = ['pserve', compiled_config, '--reload']
    return pserve.main(pserve_argv)
Example #10
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto commands")
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=CONFIG_FILE)
    parser.add_argument('--backend',
                        help='Specify backend',
                        dest='backend',
                        required=False,
                        default=None)

    parser.add_argument('-v',
                        '--version',
                        action='version',
                        version=__version__,
                        help='Print the Kinto version and exit.')

    subparsers = parser.add_subparsers(title='subcommands',
                                       description='valid subcommands',
                                       dest='subcommand',
                                       help='init/start/migrate')
    subparsers.required = True

    parser_init = subparsers.add_parser('init')
    parser_init.set_defaults(which='init')

    parser_migrate = subparsers.add_parser('migrate')
    parser_migrate.set_defaults(which='migrate')

    parser_start = subparsers.add_parser('start')
    parser_start.add_argument('--reload',
                              action='store_true',
                              help='Restart when code or config changes',
                              required=False,
                              default=False)
    parser_start.add_argument('--port',
                              type=int,
                              help='Listening port number',
                              required=False,
                              default=8888)
    parser_start.set_defaults(which='start')

    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args['ini_file']

    if parsed_args['which'] == 'init':
        if os.path.exists(config_file):
            print("%s already exists." % config_file, file=sys.stderr)
            return 1

        backend = parsed_args['backend']
        if not backend:
            while True:
                prompt = ("Select the backend you would like to use: "
                          "(1 - postgresql, 2 - redis, default - memory) ")
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend)

        # Install postgresql libraries if necessary
        if backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                import pip
                pip.main(['install', "kinto[postgresql]"])

    elif parsed_args['which'] == 'migrate':
        env = bootstrap(config_file)
        scripts.migrate(env)

    elif parsed_args['which'] == 'start':
        pserve_argv = ['pserve', config_file]
        if parsed_args['reload']:
            pserve_argv.append('--reload')
        pserve_argv.append('http_port=%s' % parsed_args['port'])
        pserve.main(pserve_argv)

    return 0
Example #11
0
import os
import sys

# curdir = os.path.dirname(os.path.abspath(__file__))
# sys.path.append(curdir)

from pyramid.scripts.pserve import main

sys.exit(main(sys.argv))
Example #12
0
from pyramid.scripts import pserve

pserve.main(['pserve', '--reload', 'development.ini'])
Example #13
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(
        description="Kinto Command-Line Interface")
    commands = (
        "init",
        "start",
        "migrate",
        "flush-cache",
        "version",
        "rebuild-quotas",
        "create-user",
    )
    subparsers = parser.add_subparsers(
        title="subcommands",
        description="Main Kinto CLI commands",
        dest="subcommand",
        help="Choose and run with --help",
    )
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        subparser.add_argument(
            "--ini",
            help="Application configuration file",
            dest="ini_file",
            required=False,
            default=DEFAULT_CONFIG_FILE,
        )

        subparser.add_argument(
            "-q",
            "--quiet",
            action="store_const",
            const=logging.CRITICAL,
            dest="verbosity",
            help="Show only critical errors.",
        )

        subparser.add_argument(
            "-v",
            "--debug",
            action="store_const",
            const=logging.DEBUG,
            dest="verbosity",
            help="Show all messages, including debug messages.",
        )

        if command == "init":
            subparser.add_argument(
                "--backend",
                help="{memory,redis,postgresql}",
                dest="backend",
                required=False,
                default=None,
            )
            subparser.add_argument(
                "--cache-backend",
                help="{memory,redis,postgresql,memcached}",
                dest="cache-backend",
                required=False,
                default=None,
            )
            subparser.add_argument(
                "--host",
                help="Host to listen() on.",
                dest="host",
                required=False,
                default="127.0.0.1",
            )

        elif command == "migrate":
            subparser.add_argument(
                "--dry-run",
                action="store_true",
                help="Simulate the migration operations and show information",
                dest="dry_run",
                required=False,
                default=False,
            )

        elif command == "rebuild-quotas":
            subparser.add_argument(
                "--dry-run",
                action="store_true",
                help="Simulate the rebuild operation and show information",
                dest="dry_run",
                required=False,
                default=False,
            )

        elif command == "start":
            subparser.add_argument(
                "--reload",
                action="store_true",
                help="Restart when code or config changes",
                required=False,
                default=False,
            )
            subparser.add_argument(
                "--port",
                type=int,
                help="Listening port number",
                required=False,
                default=DEFAULT_PORT,
            )

        elif command == "create-user":
            subparser.add_argument("-u",
                                   "--username",
                                   help="Superuser username",
                                   required=False,
                                   default=None)
            subparser.add_argument("-p",
                                   "--password",
                                   help="Superuser password",
                                   required=False,
                                   default=None)

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args["ini_file"]
    which_command = parsed_args["which"]

    # Initialize logging from
    level = parsed_args.get("verbosity") or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == "init":
        if os.path.exists(config_file):
            print(f"{config_file} already exists.", file=sys.stderr)
            return 1

        backend = parsed_args["backend"]
        cache_backend = parsed_args["cache-backend"]
        if not backend:
            while True:
                prompt = ("Select the backend you would like to use: "
                          "(1 - postgresql, 2 - redis, default - memory) ")
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        if not cache_backend:
            while True:
                prompt = (
                    "Select the cache backend you would like to use: "
                    "(1 - postgresql, 2 - redis, 3 - memcached, default - memory) "
                )
                answer = input(prompt).strip()
                try:
                    cache_backends = {
                        "1": "postgresql",
                        "2": "redis",
                        "3": "memcached",
                        "": "memory",
                    }
                    cache_backend = cache_backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend, cache_backend, parsed_args["host"])

        # Install postgresql libraries if necessary
        if backend == "postgresql" or cache_backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                subprocess.check_call([
                    sys.executable, "-m", "pip", "install", "kinto[postgresql]"
                ])
        elif backend == "redis" or cache_backend == "redis":
            try:
                import kinto_redis  # NOQA
            except ImportError:
                subprocess.check_call(
                    [sys.executable, "-m", "pip", "install", "kinto[redis]"])
        elif cache_backend == "memcached":
            try:
                import memcache  # NOQA
            except ImportError:
                subprocess.check_call([
                    sys.executable, "-m", "pip", "install", "kinto[memcached]"
                ])

    elif which_command == "migrate":
        dry_run = parsed_args["dry_run"]
        env = bootstrap(config_file, options={"command": "migrate"})
        core_scripts.migrate(env, dry_run=dry_run)

    elif which_command == "flush-cache":
        env = bootstrap(config_file, options={"command": "flush-cache"})
        core_scripts.flush_cache(env)

    elif which_command == "rebuild-quotas":
        dry_run = parsed_args["dry_run"]
        env = bootstrap(config_file, options={"command": "rebuild-quotas"})
        return kinto_scripts.rebuild_quotas(env, dry_run=dry_run)

    elif which_command == "create-user":
        username = parsed_args["username"]
        password = parsed_args["password"]
        env = bootstrap(config_file, options={"command": "create-user"})
        return accounts_scripts.create_user(env,
                                            username=username,
                                            password=password)

    elif which_command == "start":
        pserve_argv = ["pserve"]

        if parsed_args["reload"]:
            pserve_argv.append("--reload")

        if level == logging.DEBUG:
            pserve_argv.append("-v")

        if level == logging.CRITICAL:
            pserve_argv.append("-q")

        pserve_argv.append(config_file)
        pserve_argv.append(f"http_port={parsed_args['port']}")
        pserve.main(argv=pserve_argv)

    else:
        print(__version__)

    return 0
Example #14
0
from pyramid.scripts import pserve
from cornice import Service

from lpp import LPP_STATIONS


app = static_view(
    os.path.join(os.path.dirname(__file__), 'app'),
    use_subpath=True)

api_items = Service(name='api', path='/api/items')


@api_items.get()
def get_items(request):
    """ """
    return LPP_STATIONS


def main(global_config, **settings):
    config = Configurator(settings=settings)
    config.include("cornice")
    config.add_cornice_service(api_items)
    config.add_view(app, route_name='app')
    config.add_route('app', '/*subpath')
    return config.make_wsgi_app()


if __name__ == '__main__':
    pserve.main()
Example #15
0
#! ./pyshop.pex

# -*- coding: utf-8 -*-
import re
import sys

from pyramid.scripts.pserve import main

if __name__ == '__main__':
    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
    sys.exit(main())
 def _callFUT(self, argv):
     from pyramid.scripts.pserve import main
     return main(argv, quiet=True)
Example #17
0
def main(args=None):
    """The main routine."""
    
    if args is None:
        args = sys.argv[1:]
    print('hi')
    print(args)
    print('bye')
    parser = argparse.ArgumentParser(description="Kinto commands")
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=CONFIG_FILE)
    parser.add_argument('--backend',
                        help='Specify backend',
                        dest='backend',
                        required=False,
                        default=None)

    parser.add_argument('-v', '--version',
                        action='version', version=__version__,
                        help='Print the Kinto version and exit.')

    subparsers = parser.add_subparsers(title='subcommands',
                                       description='valid subcommands',
                                       help='init/start/migrate')

    parser_init = subparsers.add_parser('init')
    parser_init.set_defaults(which='init')

    parser_migrate = subparsers.add_parser('migrate')
    parser_migrate.set_defaults(which='migrate')

    parser_start = subparsers.add_parser('start')
    parser_start.add_argument('--reload',
                              action='store_true',
                              help='Restart when code or config changes',
                              required=False,
                              default=False)
    parser_start.set_defaults(which='start')

    args = vars(parser.parse_args())
    config_file = args['ini_file']

    if args['which'] == 'init':
        if os.path.exists(config_file):
            print("%s already exist." % config_file, file=sys.stderr)
            sys.exit(1)
        initstep(args,config_file)

    elif args['which'] == 'migrate':
        migratestep(args,config_file)

    elif args['which'] == 'start':
	if not os.path.exists(config_file):
		startup(args,config_file)
        pserve_argv = ['pserve', config_file]
        if args['reload']:
            pserve_argv.append('--reload')
        pserve.main(pserve_argv)
Example #18
0
def main(cli, args):
    opts = ['pserve', cli.config_file]
    pserve.main(opts)
Example #19
0
def main():
    config_ini_file = sys.argv[1]
    config_path = pkg_resources.resource_filename("adaero", config_ini_file)
    return pserve.main(argv=["pserve", config_path])
Example #20
0
#!/home/frank/DATA/Envs/env1/bin/python3
# -*- coding: utf-8 -*-
import regex as re
import sys

from pyramid.scripts.pserve import main

if __name__ == '__main__':
    sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
    sys.exit(main())
Example #21
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto commands")
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=CONFIG_FILE)
    parser.add_argument('--backend',
                        help='Specify backend',
                        dest='backend',
                        required=False,
                        default=None)

    parser.add_argument('-v', '--version',
                        action='version', version=__version__,
                        help='Print the Kinto version and exit.')

    subparsers = parser.add_subparsers(title='subcommands',
                                       description='valid subcommands',
                                       dest='subcommand',
                                       help='init/start/migrate')
    subparsers.required = True

    parser_init = subparsers.add_parser('init')
    parser_init.set_defaults(which='init')

    parser_migrate = subparsers.add_parser('migrate')
    parser_migrate.set_defaults(which='migrate')

    parser_start = subparsers.add_parser('start')
    parser_start.add_argument('--reload',
                              action='store_true',
                              help='Restart when code or config changes',
                              required=False,
                              default=False)
    parser_start.add_argument('--port',
                              type=int,
                              help='Listening port number',
                              required=False,
                              default=8888)
    parser_start.set_defaults(which='start')

    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args['ini_file']

    if parsed_args['which'] == 'init':
        if os.path.exists(config_file):
            print("%s already exists." % config_file, file=sys.stderr)
            return 1

        backend = parsed_args['backend']
        if not backend:
            while True:
                prompt = ("Select the backend you would like to use: "
                          "(1 - postgresql, 2 - redis, default - memory) ")
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend)

        # Install postgresql libraries if necessary
        if backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                import pip
                pip.main(['install', "kinto[postgresql]"])

    elif parsed_args['which'] == 'migrate':
        env = bootstrap(config_file)
        scripts.migrate(env)

    elif parsed_args['which'] == 'start':
        pserve_argv = ['pserve', config_file]
        if parsed_args['reload']:
            pserve_argv.append('--reload')
        pserve_argv.append('http_port=%s' % parsed_args['port'])
        pserve.main(pserve_argv)

    return 0
Example #22
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto Command-Line " "Interface")
    commands = (
        "init",
        "start",
        "migrate",
        "delete-collection",
        "version",
        "rebuild-quotas",
        "create-user",
    )
    subparsers = parser.add_subparsers(
        title="subcommands",
        description="Main Kinto CLI commands",
        dest="subcommand",
        help="Choose and run with --help",
    )
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        subparser.add_argument(
            "--ini",
            help="Application configuration file",
            dest="ini_file",
            required=False,
            default=DEFAULT_CONFIG_FILE,
        )

        subparser.add_argument(
            "-q",
            "--quiet",
            action="store_const",
            const=logging.CRITICAL,
            dest="verbosity",
            help="Show only critical errors.",
        )

        subparser.add_argument(
            "-v",
            "--debug",
            action="store_const",
            const=logging.DEBUG,
            dest="verbosity",
            help="Show all messages, including debug messages.",
        )

        if command == "init":
            subparser.add_argument(
                "--backend",
                help="{memory,redis,postgresql}",
                dest="backend",
                required=False,
                default=None,
            )
            subparser.add_argument(
                "--cache-backend",
                help="{memory,redis,postgresql,memcached}",
                dest="cache-backend",
                required=False,
                default=None,
            )
            subparser.add_argument(
                "--host",
                help="Host to listen() on.",
                dest="host",
                required=False,
                default="127.0.0.1",
            )
        elif command == "migrate":
            subparser.add_argument(
                "--dry-run",
                action="store_true",
                help="Simulate the migration operations " "and show information",
                dest="dry_run",
                required=False,
                default=False,
            )
        elif command == "delete-collection":
            subparser.add_argument(
                "--bucket", help="The bucket where the collection " "belongs to.", required=True
            )
            subparser.add_argument("--collection", help="The collection to remove.", required=True)

        elif command == "rebuild-quotas":
            subparser.add_argument(
                "--dry-run",
                action="store_true",
                help="Simulate the rebuild operation " "and show information",
                dest="dry_run",
                required=False,
                default=False,
            )

        elif command == "start":
            subparser.add_argument(
                "--reload",
                action="store_true",
                help="Restart when code or config changes",
                required=False,
                default=False,
            )
            subparser.add_argument(
                "--port",
                type=int,
                help="Listening port number",
                required=False,
                default=DEFAULT_PORT,
            )

        elif command == "create-user":
            subparser.add_argument(
                "-u", "--username", help="Superuser username", required=False, default=None
            )
            subparser.add_argument(
                "-p", "--password", help="Superuser password", required=False, default=None
            )

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args["ini_file"]
    which_command = parsed_args["which"]

    # Initialize logging from
    level = parsed_args.get("verbosity") or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == "init":
        if os.path.exists(config_file):
            print("{} already exists.".format(config_file), file=sys.stderr)
            return 1

        backend = parsed_args["backend"]
        cache_backend = parsed_args["cache-backend"]
        if not backend:
            while True:
                prompt = (
                    "Select the backend you would like to use: "
                    "(1 - postgresql, 2 - redis, default - memory) "
                )
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        if not cache_backend:
            while True:
                prompt = (
                    "Select the cache backend you would like to use: "
                    "(1 - postgresql, 2 - redis, 3 - memcached, default - memory) "
                )
                answer = input(prompt).strip()
                try:
                    cache_backends = {
                        "1": "postgresql",
                        "2": "redis",
                        "3": "memcached",
                        "": "memory",
                    }
                    cache_backend = cache_backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend, cache_backend, parsed_args["host"])

        # Install postgresql libraries if necessary
        if backend == "postgresql" or cache_backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                subprocess.check_call(
                    [sys.executable, "-m", "pip", "install", "kinto[postgresql]"]
                )
        elif backend == "redis" or cache_backend == "redis":
            try:
                import kinto_redis  # NOQA
            except ImportError:
                subprocess.check_call([sys.executable, "-m", "pip", "install", "kinto[redis]"])
        elif cache_backend == "memcached":
            try:
                import memcache  # NOQA
            except ImportError:
                subprocess.check_call([sys.executable, "-m", "pip", "install", "kinto[memcached]"])

    elif which_command == "migrate":
        dry_run = parsed_args["dry_run"]
        env = bootstrap(config_file, options={"command": "migrate"})
        scripts.migrate(env, dry_run=dry_run)

    elif which_command == "delete-collection":
        env = bootstrap(config_file, options={"command": "delete-collection"})
        return scripts.delete_collection(env, parsed_args["bucket"], parsed_args["collection"])

    elif which_command == "rebuild-quotas":
        dry_run = parsed_args["dry_run"]
        env = bootstrap(config_file, options={"command": "rebuild-quotas"})
        return scripts.rebuild_quotas(env, dry_run=dry_run)

    elif which_command == "create-user":
        username = parsed_args["username"]
        password = parsed_args["password"]
        env = bootstrap(config_file, options={"command": "create-user"})
        return create_user(env, username=username, password=password)

    elif which_command == "start":
        pserve_argv = ["pserve"]

        if parsed_args["reload"]:
            pserve_argv.append("--reload")

        if level == logging.DEBUG:
            pserve_argv.append("-v")

        if level == logging.CRITICAL:
            pserve_argv.append("-q")

        pserve_argv.append(config_file)
        pserve_argv.append("http_port={}".format(parsed_args["port"]))
        pserve.main(argv=pserve_argv)

    else:
        print(__version__)

    return 0
Example #23
0
import os
import sys

#curdir = os.path.dirname(os.path.abspath(__file__))
#sys.path.append(curdir)

from pyramid.scripts.pserve import main

sys.exit(main(sys.argv))
Example #24
0
 def _callFUT(self, argv):
     from pyramid.scripts.pserve import main
     return main(argv, quiet=True)
Example #25
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description='Kinto Command-Line '
                                                 'Interface')
    commands = ('init', 'start', 'migrate', 'delete-collection', 'version',
                'rebuild-quotas', 'create-user')
    subparsers = parser.add_subparsers(title='subcommands',
                                       description='Main Kinto CLI commands',
                                       dest='subcommand',
                                       help='Choose and run with --help')
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        subparser.add_argument('--ini',
                               help='Application configuration file',
                               dest='ini_file',
                               required=False,
                               default=DEFAULT_CONFIG_FILE)

        subparser.add_argument('-q', '--quiet', action='store_const',
                               const=logging.CRITICAL, dest='verbosity',
                               help='Show only critical errors.')

        subparser.add_argument('-v', '--debug', action='store_const',
                               const=logging.DEBUG, dest='verbosity',
                               help='Show all messages, including debug messages.')

        if command == 'init':
            subparser.add_argument('--backend',
                                   help='{memory,redis,postgresql}',
                                   dest='backend',
                                   required=False,
                                   default=None)
            subparser.add_argument('--host',
                                   help='Host to listen() on.',
                                   dest='host',
                                   required=False,
                                   default='127.0.0.1')
        elif command == 'migrate':
            subparser.add_argument('--dry-run',
                                   action='store_true',
                                   help='Simulate the migration operations '
                                        'and show information',
                                   dest='dry_run',
                                   required=False,
                                   default=False)
        elif command == 'delete-collection':
            subparser.add_argument('--bucket',
                                   help='The bucket where the collection '
                                        'belongs to.',
                                   required=True)
            subparser.add_argument('--collection',
                                   help='The collection to remove.',
                                   required=True)

        elif command == 'rebuild-quotas':
            subparser.add_argument('--dry-run',
                                   action='store_true',
                                   help='Simulate the rebuild operation '
                                        'and show information',
                                   dest='dry_run',
                                   required=False,
                                   default=False)

        elif command == 'start':
            subparser.add_argument('--reload',
                                   action='store_true',
                                   help='Restart when code or config changes',
                                   required=False,
                                   default=False)
            subparser.add_argument('--port',
                                   type=int,
                                   help='Listening port number',
                                   required=False,
                                   default=DEFAULT_PORT)

        elif command == 'create-user':
            subparser.add_argument('-u', '--username',
                                   help='Superuser username',
                                   required=False,
                                   default=None)
            subparser.add_argument('-p', '--password',
                                   help='Superuser password',
                                   required=False,
                                   default=None)

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args['ini_file']
    which_command = parsed_args['which']

    # Initialize logging from
    level = parsed_args.get('verbosity') or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == 'init':
        if os.path.exists(config_file):
            print('{} already exists.'.format(config_file), file=sys.stderr)
            return 1

        backend = parsed_args['backend']
        if not backend:
            while True:
                prompt = ('Select the backend you would like to use: '
                          '(1 - postgresql, 2 - redis, default - memory) ')
                answer = input(prompt).strip()
                try:
                    backends = {'1': 'postgresql', '2': 'redis', '': 'memory'}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend, parsed_args['host'])

        # Install postgresql libraries if necessary
        if backend == 'postgresql':
            try:
                import psycopg2  # NOQA
            except ImportError:
                subprocess.check_call([sys.executable, '-m', 'pip',
                                       'install', 'kinto[postgresql]'])
        elif backend == 'redis':
            try:
                import kinto_redis  # NOQA
            except ImportError:
                subprocess.check_call([sys.executable, '-m', 'pip',
                                       'install', 'kinto[redis]'])

    elif which_command == 'migrate':
        dry_run = parsed_args['dry_run']
        env = bootstrap(config_file)
        scripts.migrate(env, dry_run=dry_run)

    elif which_command == 'delete-collection':
        env = bootstrap(config_file)
        return scripts.delete_collection(env,
                                         parsed_args['bucket'],
                                         parsed_args['collection'])

    elif which_command == 'rebuild-quotas':
        dry_run = parsed_args['dry_run']
        env = bootstrap(config_file)
        return scripts.rebuild_quotas(env, dry_run=dry_run)

    elif which_command == 'create-user':
        username = parsed_args['username']
        password = parsed_args['password']
        env = bootstrap(config_file)
        return create_user(env, username=username, password=password)

    elif which_command == 'start':
        pserve_argv = ['pserve']

        if parsed_args['reload']:
            pserve_argv.append('--reload')

        if level == logging.DEBUG:
            pserve_argv.append('-v')

        if level == logging.CRITICAL:
            pserve_argv.append('-q')

        pserve_argv.append(config_file)
        pserve_argv.append('http_port={}'.format(parsed_args['port']))
        pserve.main(argv=pserve_argv)

    else:
        print(__version__)

    return 0
Example #26
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto Command-Line "
                                                 "Interface")
    # XXX: deprecate this option, unnatural as first argument.
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=DEFAULT_CONFIG_FILE)

    parser.add_argument('-q', '--quiet', action='store_const',
                        const=logging.CRITICAL, dest='verbosity',
                        help='Show only critical errors.')

    parser.add_argument('--debug', action='store_const',
                        const=logging.DEBUG, dest='verbosity',
                        help='Show all messages, including debug messages.')

    commands = ('init', 'start', 'migrate', 'delete-collection', 'version')
    subparsers = parser.add_subparsers(title='subcommands',
                                       description='Main Kinto CLI commands',
                                       dest='subcommand',
                                       help="Choose and run with --help")
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        if command == 'init':
            subparser.add_argument('--backend',
                                   help='{memory,redis,postgresql}',
                                   dest='backend',
                                   required=False,
                                   default=None)
        elif command == 'migrate':
            subparser.add_argument('--dry-run',
                                   action='store_true',
                                   help='Simulate the migration operations '
                                        'and show information',
                                   dest='dry_run',
                                   required=False,
                                   default=False)
        elif command == 'delete-collection':
            subparser.add_argument('--bucket',
                                   help='The bucket where the collection '
                                        'belongs to.',
                                   required=True)
            subparser.add_argument('--collection',
                                   help='The collection to remove.',
                                   required=True)

        elif command == 'start':
            subparser.add_argument('--reload',
                                   action='store_true',
                                   help='Restart when code or config changes',
                                   required=False,
                                   default=False)
            subparser.add_argument('--port',
                                   type=int,
                                   help='Listening port number',
                                   required=False,
                                   default=DEFAULT_PORT)

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args['ini_file']
    which_command = parsed_args['which']

    # Initialize logging from
    level = parsed_args.get('verbosity') or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == 'init':
        if os.path.exists(config_file):
            print("%s already exists." % config_file, file=sys.stderr)
            return 1

        backend = parsed_args['backend']
        if not backend:
            while True:
                prompt = ("Select the backend you would like to use: "
                          "(1 - postgresql, 2 - redis, default - memory) ")
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend)

        # Install postgresql libraries if necessary
        if backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                import pip
                pip.main(['install', "kinto[postgresql]"])

    elif which_command == 'migrate':
        dry_run = parsed_args['dry_run']
        env = bootstrap(config_file)
        scripts.migrate(env, dry_run=dry_run)

    elif which_command == 'delete-collection':
        env = bootstrap(config_file)
        return scripts.delete_collection(env,
                                         parsed_args['bucket'],
                                         parsed_args['collection'])

    elif which_command == 'start':
        pserve_argv = ['pserve', config_file]
        if parsed_args['reload']:
            pserve_argv.append('--reload')
        pserve_argv.append('http_port=%s' % parsed_args['port'])
        pserve.main(pserve_argv)

    elif which_command == 'version':
        print(__version__)

    return 0
Example #27
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description='Kinto Command-Line '
                                     'Interface')
    commands = ('init', 'start', 'migrate', 'delete-collection', 'version',
                'rebuild-quotas', 'create-user')
    subparsers = parser.add_subparsers(title='subcommands',
                                       description='Main Kinto CLI commands',
                                       dest='subcommand',
                                       help='Choose and run with --help')
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        subparser.add_argument('--ini',
                               help='Application configuration file',
                               dest='ini_file',
                               required=False,
                               default=DEFAULT_CONFIG_FILE)

        subparser.add_argument('-q',
                               '--quiet',
                               action='store_const',
                               const=logging.CRITICAL,
                               dest='verbosity',
                               help='Show only critical errors.')

        subparser.add_argument(
            '-v',
            '--debug',
            action='store_const',
            const=logging.DEBUG,
            dest='verbosity',
            help='Show all messages, including debug messages.')

        if command == 'init':
            subparser.add_argument('--backend',
                                   help='{memory,redis,postgresql}',
                                   dest='backend',
                                   required=False,
                                   default=None)
            subparser.add_argument('--cache-backend',
                                   help='{memory,redis,postgresql,memcached}',
                                   dest='cache-backend',
                                   required=False,
                                   default=None)
            subparser.add_argument('--host',
                                   help='Host to listen() on.',
                                   dest='host',
                                   required=False,
                                   default='127.0.0.1')
        elif command == 'migrate':
            subparser.add_argument('--dry-run',
                                   action='store_true',
                                   help='Simulate the migration operations '
                                   'and show information',
                                   dest='dry_run',
                                   required=False,
                                   default=False)
        elif command == 'delete-collection':
            subparser.add_argument('--bucket',
                                   help='The bucket where the collection '
                                   'belongs to.',
                                   required=True)
            subparser.add_argument('--collection',
                                   help='The collection to remove.',
                                   required=True)

        elif command == 'rebuild-quotas':
            subparser.add_argument('--dry-run',
                                   action='store_true',
                                   help='Simulate the rebuild operation '
                                   'and show information',
                                   dest='dry_run',
                                   required=False,
                                   default=False)

        elif command == 'start':
            subparser.add_argument('--reload',
                                   action='store_true',
                                   help='Restart when code or config changes',
                                   required=False,
                                   default=False)
            subparser.add_argument('--port',
                                   type=int,
                                   help='Listening port number',
                                   required=False,
                                   default=DEFAULT_PORT)

        elif command == 'create-user':
            subparser.add_argument('-u',
                                   '--username',
                                   help='Superuser username',
                                   required=False,
                                   default=None)
            subparser.add_argument('-p',
                                   '--password',
                                   help='Superuser password',
                                   required=False,
                                   default=None)

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args['ini_file']
    which_command = parsed_args['which']

    # Initialize logging from
    level = parsed_args.get('verbosity') or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == 'init':
        if os.path.exists(config_file):
            print('{} already exists.'.format(config_file), file=sys.stderr)
            return 1

        backend = parsed_args['backend']
        cache_backend = parsed_args['cache-backend']
        if not backend:
            while True:
                prompt = ('Select the backend you would like to use: '
                          '(1 - postgresql, 2 - redis, default - memory) ')
                answer = input(prompt).strip()
                try:
                    backends = {'1': 'postgresql', '2': 'redis', '': 'memory'}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        if not cache_backend:
            while True:
                prompt = (
                    'Select the cache backend you would like to use: '
                    '(1 - postgresql, 2 - redis, 3 - memcached, default - memory) '
                )
                answer = input(prompt).strip()
                try:
                    cache_backends = {
                        '1': 'postgresql',
                        '2': 'redis',
                        '3': 'memcached',
                        '': 'memory'
                    }
                    cache_backend = cache_backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend, cache_backend, parsed_args['host'])

        # Install postgresql libraries if necessary
        if backend == 'postgresql' or cache_backend == 'postgresql':
            try:
                import psycopg2  # NOQA
            except ImportError:
                subprocess.check_call([
                    sys.executable, '-m', 'pip', 'install', 'kinto[postgresql]'
                ])
        elif backend == 'redis' or cache_backend == 'redis':
            try:
                import kinto_redis  # NOQA
            except ImportError:
                subprocess.check_call(
                    [sys.executable, '-m', 'pip', 'install', 'kinto[redis]'])
        elif cache_backend == 'memcached':
            try:
                import memcache  # NOQA
            except ImportError:
                subprocess.check_call([
                    sys.executable, '-m', 'pip', 'install', 'kinto[memcached]'
                ])

    elif which_command == 'migrate':
        dry_run = parsed_args['dry_run']
        env = bootstrap(config_file, options={'command': 'migrate'})
        scripts.migrate(env, dry_run=dry_run)

    elif which_command == 'delete-collection':
        env = bootstrap(config_file, options={'command': 'delete-collection'})
        return scripts.delete_collection(env, parsed_args['bucket'],
                                         parsed_args['collection'])

    elif which_command == 'rebuild-quotas':
        dry_run = parsed_args['dry_run']
        env = bootstrap(config_file, options={'command': 'rebuild-quotas'})
        return scripts.rebuild_quotas(env, dry_run=dry_run)

    elif which_command == 'create-user':
        username = parsed_args['username']
        password = parsed_args['password']
        env = bootstrap(config_file, options={'command': 'create-user'})
        return create_user(env, username=username, password=password)

    elif which_command == 'start':
        pserve_argv = ['pserve']

        if parsed_args['reload']:
            pserve_argv.append('--reload')

        if level == logging.DEBUG:
            pserve_argv.append('-v')

        if level == logging.CRITICAL:
            pserve_argv.append('-q')

        pserve_argv.append(config_file)
        pserve_argv.append('http_port={}'.format(parsed_args['port']))
        pserve.main(argv=pserve_argv)

    else:
        print(__version__)

    return 0
Example #28
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto Command-Line "
                                     "Interface")
    # XXX: deprecate this option, unnatural as first argument.
    parser.add_argument('--ini',
                        help='Application configuration file',
                        dest='ini_file',
                        required=False,
                        default=DEFAULT_CONFIG_FILE)

    parser.add_argument('-q',
                        '--quiet',
                        action='store_const',
                        const=logging.CRITICAL,
                        dest='verbosity',
                        help='Show only critical errors.')

    parser.add_argument('--debug',
                        action='store_const',
                        const=logging.DEBUG,
                        dest='verbosity',
                        help='Show all messages, including debug messages.')

    commands = ('init', 'start', 'migrate', 'delete-collection', 'version')
    subparsers = parser.add_subparsers(title='subcommands',
                                       description='Main Kinto CLI commands',
                                       dest='subcommand',
                                       help="Choose and run with --help")
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        if command == 'init':
            subparser.add_argument('--backend',
                                   help='{memory,redis,postgresql}',
                                   dest='backend',
                                   required=False,
                                   default=None)
            subparser.add_argument('--host',
                                   help='Host to listen() on.',
                                   dest='host',
                                   required=False,
                                   default='127.0.0.1')
        elif command == 'migrate':
            subparser.add_argument('--dry-run',
                                   action='store_true',
                                   help='Simulate the migration operations '
                                   'and show information',
                                   dest='dry_run',
                                   required=False,
                                   default=False)
        elif command == 'delete-collection':
            subparser.add_argument('--bucket',
                                   help='The bucket where the collection '
                                   'belongs to.',
                                   required=True)
            subparser.add_argument('--collection',
                                   help='The collection to remove.',
                                   required=True)

        elif command == 'start':
            subparser.add_argument('--reload',
                                   action='store_true',
                                   help='Restart when code or config changes',
                                   required=False,
                                   default=False)
            subparser.add_argument('--port',
                                   type=int,
                                   help='Listening port number',
                                   required=False,
                                   default=DEFAULT_PORT)

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args['ini_file']
    which_command = parsed_args['which']

    # Initialize logging from
    level = parsed_args.get('verbosity') or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == 'init':
        if os.path.exists(config_file):
            print("%s already exists." % config_file, file=sys.stderr)
            return 1

        backend = parsed_args['backend']
        if not backend:
            while True:
                prompt = ("Select the backend you would like to use: "
                          "(1 - postgresql, 2 - redis, default - memory) ")
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend, parsed_args['host'])

        # Install postgresql libraries if necessary
        if backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                import pip
                pip.main(['install', "kinto[postgresql]"])
        elif backend == "redis":
            try:
                import kinto_redis  # NOQA
            except ImportError:
                import pip
                pip.main(['install', "kinto[redis]"])

    elif which_command == 'migrate':
        dry_run = parsed_args['dry_run']
        env = bootstrap(config_file)
        scripts.migrate(env, dry_run=dry_run)

    elif which_command == 'delete-collection':
        env = bootstrap(config_file)
        return scripts.delete_collection(env, parsed_args['bucket'],
                                         parsed_args['collection'])

    elif which_command == 'start':
        pserve_argv = ['pserve', config_file]
        if parsed_args['reload']:
            pserve_argv.append('--reload')
        pserve_argv.append('http_port=%s' % parsed_args['port'])
        pserve.main(pserve_argv)

    elif which_command == 'version':
        print(__version__)

    return 0
Example #29
0
def main(args=None):
    """The main routine."""
    if args is None:
        args = sys.argv[1:]

    parser = argparse.ArgumentParser(description="Kinto Command-Line " "Interface")
    # XXX: deprecate this option, unnatural as first argument.
    parser.add_argument(
        "--ini", help="Application configuration file", dest="ini_file", required=False, default=DEFAULT_CONFIG_FILE
    )

    parser.add_argument(
        "-q",
        "--quiet",
        action="store_const",
        const=logging.CRITICAL,
        dest="verbosity",
        help="Show only critical errors.",
    )

    parser.add_argument(
        "--debug",
        action="store_const",
        const=logging.DEBUG,
        dest="verbosity",
        help="Show all messages, including debug messages.",
    )

    commands = ("init", "start", "migrate", "delete-collection", "version")
    subparsers = parser.add_subparsers(
        title="subcommands", description="Main Kinto CLI commands", dest="subcommand", help="Choose and run with --help"
    )
    subparsers.required = True

    for command in commands:
        subparser = subparsers.add_parser(command)
        subparser.set_defaults(which=command)

        if command == "init":
            subparser.add_argument(
                "--backend", help="{memory,redis,postgresql}", dest="backend", required=False, default=None
            )
        elif command == "migrate":
            subparser.add_argument(
                "--dry-run",
                action="store_true",
                help="Simulate the migration operations " "and show information",
                dest="dry_run",
                required=False,
                default=False,
            )
        elif command == "delete-collection":
            subparser.add_argument("--bucket", help="The bucket where the collection " "belongs to.", required=True)
            subparser.add_argument("--collection", help="The collection to remove.", required=True)

        elif command == "start":
            subparser.add_argument(
                "--reload",
                action="store_true",
                help="Restart when code or config changes",
                required=False,
                default=False,
            )
            subparser.add_argument(
                "--port", type=int, help="Listening port number", required=False, default=DEFAULT_PORT
            )

    # Parse command-line arguments
    parsed_args = vars(parser.parse_args(args))

    config_file = parsed_args["ini_file"]
    which_command = parsed_args["which"]

    # Initialize logging from
    level = parsed_args.get("verbosity") or DEFAULT_LOG_LEVEL
    logging.basicConfig(level=level, format=DEFAULT_LOG_FORMAT)

    if which_command == "init":
        if os.path.exists(config_file):
            print("%s already exists." % config_file, file=sys.stderr)
            return 1

        backend = parsed_args["backend"]
        if not backend:
            while True:
                prompt = "Select the backend you would like to use: " "(1 - postgresql, 2 - redis, default - memory) "
                answer = input(prompt).strip()
                try:
                    backends = {"1": "postgresql", "2": "redis", "": "memory"}
                    backend = backends[answer]
                    break
                except KeyError:
                    pass

        init(config_file, backend)

        # Install postgresql libraries if necessary
        if backend == "postgresql":
            try:
                import psycopg2  # NOQA
            except ImportError:
                import pip

                pip.main(["install", "kinto[postgresql]"])
        elif backend == "redis":
            try:
                import kinto_redis  # NOQA
            except ImportError:
                import pip

                pip.main(["install", "kinto[redis]"])

    elif which_command == "migrate":
        dry_run = parsed_args["dry_run"]
        env = bootstrap(config_file)
        scripts.migrate(env, dry_run=dry_run)

    elif which_command == "delete-collection":
        env = bootstrap(config_file)
        return scripts.delete_collection(env, parsed_args["bucket"], parsed_args["collection"])

    elif which_command == "start":
        pserve_argv = ["pserve", config_file]
        if parsed_args["reload"]:
            pserve_argv.append("--reload")
        pserve_argv.append("http_port=%s" % parsed_args["port"])
        pserve.main(pserve_argv)

    elif which_command == "version":
        print(__version__)

    return 0