Beispiel #1
0
 def test_migrate_skips_missing_backends(self):
     class FakeRegistry:
         settings = dict()
         storage = mock.MagicMock()
     registry = FakeRegistry()
     scripts.migrate({'registry': registry})
     self.assertTrue(registry.storage.initialize_schema.called)
Beispiel #2
0
 def test_migrate_in_read_only_display_an_error(self):
     with mock.patch('kinto.core.scripts.logger') as mocked:
         self.registry.settings = {'readonly': 'true'}
         scripts.migrate({'registry': self.registry})
         mocked.error.assert_any_call('Cannot migrate the storage backend '
                                      'while in readonly mode.')
         mocked.error.assert_any_call('Cannot migrate the permission '
                                      'backend while in readonly mode.')
Beispiel #3
0
 def test_migrate_in_read_only_display_an_error(self):
     with mock.patch("kinto.core.scripts.logger") as mocked:
         self.registry.settings = {"readonly": "true"}
         scripts.migrate({"registry": self.registry})
         mocked.error.assert_any_call("Cannot migrate the storage backend "
                                      "while in readonly mode.")
         mocked.error.assert_any_call("Cannot migrate the permission "
                                      "backend while in readonly mode.")
Beispiel #4
0
 def test_migrate_in_read_only_display_an_error(self):
     with mock.patch('kinto.core.scripts.logger') as mocked:
         self.registry.settings = {'readonly': 'true'}
         scripts.migrate({'registry': self.registry})
         mocked.error.assert_any_call('Cannot migrate the storage backend '
                                      'while in readonly mode.')
         mocked.error.assert_any_call('Cannot migrate the permission '
                                      'backend while in readonly mode.')
Beispiel #5
0
 def test_migrate_in_read_only_display_an_error(self):
     with mock.patch("kinto.core.scripts.logger") as mocked:
         self.registry.settings = {"readonly": "true"}
         scripts.migrate({"registry": self.registry})
         mocked.error.assert_any_call(
             "Cannot migrate the storage backend " "while in readonly mode."
         )
         mocked.error.assert_any_call(
             "Cannot migrate the permission " "backend while in readonly mode."
         )
def main(argv=sys.argv):
    if len(argv) != 2:
        usage(argv)
    config_uri = argv[1]
    setup_logging(config_uri)
    settings = get_appsettings(config_uri)
    engine = engine_from_config(settings, 'sqlalchemy.')
    Session.configure(bind=engine)
    migrate(bootstrap(config_uri))
    logger.info('Drop and create tables')
    Base.metadata.drop_all(engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        preload_countries()
        preload_cities()
Beispiel #7
0
 def test_migrate_calls_initialize_schema_on_backends(self):
     scripts.migrate({'registry': self.registry})
     self.assertTrue(self.registry.storage.initialize_schema.called)
     self.assertTrue(self.registry.cache.initialize_schema.called)
     self.assertTrue(self.registry.permission.initialize_schema.called)
Beispiel #8
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
Beispiel #9
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
Beispiel #10
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
Beispiel #11
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
Beispiel #12
0
 def test_migrate_calls_initialize_schema_on_backends(self):
     scripts.migrate({"registry": self.registry})
     self.assertTrue(self.registry.storage.initialize_schema.called)
     self.assertTrue(self.registry.cache.initialize_schema.called)
     self.assertTrue(self.registry.permission.initialize_schema.called)
Beispiel #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
Beispiel #14
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
Beispiel #15
0
 def test_migrate_in_dry_run_mode(self):
     scripts.migrate({'registry': self.registry}, dry_run=True)
     reg = self.registry
     reg.storage.initialize_schema.assert_called_with(dry_run=True)
     reg.cache.initialize_schema.assert_called_with(dry_run=True)
     reg.permission.initialize_schema.assert_called_with(dry_run=True)
Beispiel #16
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
Beispiel #17
0
 def test_migrate_in_dry_run_mode(self):
     scripts.migrate({"registry": self.registry}, dry_run=True)
     reg = self.registry
     reg.storage.initialize_schema.assert_called_with(dry_run=True)
     reg.cache.initialize_schema.assert_called_with(dry_run=True)
     reg.permission.initialize_schema.assert_called_with(dry_run=True)
Beispiel #18
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
Beispiel #19
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