Ejemplo n.º 1
0
    def test_delete_collection_remove_collection_records(self):
        self.registry.storage.delete_all.return_value = [
            {"id": "1234"}, {"id": "5678"}
        ]

        with mock.patch('kinto.core.scripts.logger') as mocked:
            scripts.delete_collection({'registry': self.registry},
                                      'test_bucket',
                                      'test_collection')

        self.registry.storage.delete_all.assert_called_with(
            collection_id='record',
            parent_id='/buckets/test_bucket/collections/test_collection',
            with_deleted=False)
        self.registry.storage.delete.assert_called_with(
            collection_id='collection',
            parent_id='/buckets/test_bucket',
            object_id='test_collection',
            with_deleted=False)
        self.registry.permission.delete_object_permissions.assert_called_with(
            '/buckets/test_bucket/collections/test_collection',
            '/buckets/test_bucket/collections/test_collection/records/1234',
            '/buckets/test_bucket/collections/test_collection/records/5678')

        mocked.info.assert_any_call('2 record(s) were deleted.')
        mocked.info.assert_any_call(
            "'/buckets/test_bucket/collections/test_collection' "
            "collection object was deleted.")
Ejemplo n.º 2
0
    def test_delete_collection_remove_collection_records(self):
        self.registry.storage.delete_all.return_value = [{
            "id": "1234"
        }, {
            "id": "5678"
        }]

        with mock.patch("kinto.core.scripts.logger") as mocked:
            scripts.delete_collection({"registry": self.registry},
                                      "test_bucket", "test_collection")

        self.registry.storage.delete_all.assert_called_with(
            collection_id="record",
            parent_id="/buckets/test_bucket/collections/test_collection",
            with_deleted=False,
        )
        self.registry.storage.delete.assert_called_with(
            collection_id="collection",
            parent_id="/buckets/test_bucket",
            object_id="test_collection",
            with_deleted=False,
        )
        self.registry.permission.delete_object_permissions.assert_called_with(
            "/buckets/test_bucket/collections/test_collection",
            "/buckets/test_bucket/collections/test_collection/records/1234",
            "/buckets/test_bucket/collections/test_collection/records/5678",
        )

        mocked.info.assert_any_call("2 record(s) were deleted.")
        mocked.info.assert_any_call(
            "'/buckets/test_bucket/collections/test_collection' "
            "collection object was deleted.")
Ejemplo n.º 3
0
    def test_delete_collection_remove_collection_records(self):
        self.registry.storage.delete_all.return_value = [{
            "id": "1234"
        }, {
            "id": "5678"
        }]

        with mock.patch('kinto.core.scripts.logger') as mocked:
            scripts.delete_collection({'registry': self.registry},
                                      'test_bucket', 'test_collection')

        self.registry.storage.delete_all.assert_called_with(
            collection_id='record',
            parent_id='/buckets/test_bucket/collections/test_collection',
            with_deleted=False)
        self.registry.storage.delete.assert_called_with(
            collection_id='collection',
            parent_id='/buckets/test_bucket',
            object_id='test_collection',
            with_deleted=False)
        self.registry.permission.delete_object_permissions.assert_called_with(
            '/buckets/test_bucket/collections/test_collection',
            '/buckets/test_bucket/collections/test_collection/records/1234',
            '/buckets/test_bucket/collections/test_collection/records/5678')

        mocked.info.assert_any_call('2 record(s) were deleted.')
        mocked.info.assert_any_call(
            "'/buckets/test_bucket/collections/test_collection' "
            "collection object was deleted.")
Ejemplo n.º 4
0
    def test_delete_collection_remove_collection_records(self):
        self.registry.storage.delete_all.return_value = [{"id": "1234"}, {"id": "5678"}]

        with mock.patch("kinto.core.scripts.logger") as mocked:
            scripts.delete_collection({"registry": self.registry}, "test_bucket", "test_collection")

        self.registry.storage.delete_all.assert_called_with(
            collection_id="record", parent_id="/buckets/test_bucket/collections/test_collection", with_deleted=False
        )
        self.registry.storage.delete.assert_called_with(
            collection_id="collection",
            parent_id="/buckets/test_bucket",
            object_id="test_collection",
            with_deleted=False,
        )
        self.registry.permission.delete_object_permissions.assert_called_with(
            "/buckets/test_bucket/collections/test_collection",
            "/buckets/test_bucket/collections/test_collection/records/1234",
            "/buckets/test_bucket/collections/test_collection/records/5678",
        )

        mocked.info.assert_any_call("2 record(s) were deleted.")
        mocked.info.assert_any_call(
            "'/buckets/test_bucket/collections/test_collection' " "collection object was deleted."
        )
Ejemplo n.º 5
0
    def test_delete_collection_tell_when_no_records_where_found(self):
        self.registry.storage.delete_all.return_value = []

        with mock.patch("kinto.core.scripts.logger") as mocked:
            scripts.delete_collection({"registry": self.registry}, "test_bucket", "test_collection")

        mocked.info.assert_any_call("No records found for " "'/buckets/test_bucket/collections/test_collection'.")
        mocked.info.assert_any_call(
            "'/buckets/test_bucket/collections/test_collection' " "collection object was deleted."
        )
        mocked.info.assert_any_call("Related permissions were deleted.")
Ejemplo n.º 6
0
    def test_delete_collection_tell_when_no_records_where_found(self):
        self.registry.storage.delete_all.return_value = []

        with mock.patch('kinto.core.scripts.logger') as mocked:
            scripts.delete_collection({'registry': self.registry},
                                      'test_bucket', 'test_collection')

        mocked.info.assert_any_call(
            "No records found for "
            "'/buckets/test_bucket/collections/test_collection'.")
        mocked.info.assert_any_call(
            "'/buckets/test_bucket/collections/test_collection' "
            "collection object was deleted.")
        mocked.info.assert_any_call("Related permissions were deleted.")
Ejemplo n.º 7
0
 def test_delete_collection_raise_if_the_collection_does_not_exist(self):
     self.registry.storage.get.side_effect = ["", RecordNotFoundError]
     with mock.patch("kinto.core.scripts.logger") as mocked:
         resp = scripts.delete_collection({"registry": self.registry}, "test_bucket", "test_collection")
     assert resp == 33
     mocked.error.assert_called_with(
         "Collection '/buckets/test_bucket/collections/test_collection' " "does not exist."
     )
Ejemplo n.º 8
0
 def test_delete_collection_in_read_only_display_an_error(self):
     with mock.patch('kinto.core.scripts.logger') as mocked:
         self.registry.settings = {'readonly': 'true'}
         code = scripts.delete_collection({'registry': self.registry},
                                          'test_bucket', 'test_collection')
         assert code == 31
         mocked.error.assert_any_call('Cannot delete the collection while '
                                      'in readonly mode.')
Ejemplo n.º 9
0
 def test_delete_collection_in_read_only_display_an_error(self):
     with mock.patch("kinto.core.scripts.logger") as mocked:
         self.registry.settings = {"readonly": "true"}
         code = scripts.delete_collection(
             {"registry": self.registry}, "test_bucket", "test_collection"
         )
         assert code == 31
         mocked.error.assert_any_call("Cannot delete the collection while " "in readonly mode.")
Ejemplo n.º 10
0
 def test_delete_collection_raise_if_the_bucket_does_not_exist(self):
     self.registry.storage.get.side_effect = RecordNotFoundError
     with mock.patch('kinto.core.scripts.logger') as mocked:
         resp = scripts.delete_collection({'registry': self.registry},
                                          'test_bucket', 'test_collection')
     assert resp == 32
     mocked.error.assert_called_with(
         "Bucket '/buckets/test_bucket' does not exist.")
Ejemplo n.º 11
0
 def test_delete_collection_in_read_only_display_an_error(self):
     with mock.patch("kinto.core.scripts.logger") as mocked:
         self.registry.settings = {"readonly": "true"}
         code = scripts.delete_collection({"registry": self.registry},
                                          "test_bucket", "test_collection")
         assert code == 31
         mocked.error.assert_any_call("Cannot delete the collection while "
                                      "in readonly mode.")
Ejemplo n.º 12
0
 def test_delete_collection_raise_if_the_bucket_does_not_exist(self):
     self.registry.storage.get.side_effect = RecordNotFoundError
     with mock.patch('kinto.core.scripts.logger') as mocked:
         resp = scripts.delete_collection({'registry': self.registry},
                                          'test_bucket',
                                          'test_collection')
     assert resp == 32
     mocked.error.assert_called_with(
         "Bucket '/buckets/test_bucket' does not exist.")
Ejemplo n.º 13
0
 def test_delete_collection_raise_if_the_collection_does_not_exist(self):
     self.registry.storage.get.side_effect = ["", RecordNotFoundError]
     with mock.patch("kinto.core.scripts.logger") as mocked:
         resp = scripts.delete_collection({"registry": self.registry},
                                          "test_bucket", "test_collection")
     assert resp == 33
     mocked.error.assert_called_with(
         "Collection '/buckets/test_bucket/collections/test_collection' "
         "does not exist.")
Ejemplo n.º 14
0
 def test_delete_collection_in_read_only_display_an_error(self):
     with mock.patch('kinto.core.scripts.logger') as mocked:
         self.registry.settings = {'readonly': 'true'}
         code = scripts.delete_collection({'registry': self.registry},
                                          'test_bucket',
                                          'test_collection')
         assert code == 31
         mocked.error.assert_any_call('Cannot delete the collection while '
                                      'in readonly mode.')
Ejemplo n.º 15
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
Ejemplo n.º 16
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
Ejemplo n.º 17
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
Ejemplo n.º 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)
        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
Ejemplo n.º 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(
                "--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(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"})
        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(f"http_port={parsed_args['port']}")
        pserve.main(argv=pserve_argv)

    else:
        print(__version__)

    return 0
Ejemplo n.º 20
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
Ejemplo n.º 21
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