vgs-cli 0.0.1.dev0__py3-none-any.whl

vgscli/cli/commands/get.py

@@ -0,0 +1,200 @@
+import click
+from click_plugins import with_plugins
+from simple_rest_client.exceptions import ClientError, ServerError
+from vgs.sdk.routes import dump_all_routes, normalize
+from vgs.sdk.serializers import yaml  # this one correctly outputs blocks
+from vgs.sdk.vaults_api import create_api as create_vault_mgmt_api_routes
+
+from vgscli.auth import handshake, token_util
+from vgscli.cert_manager_api import create_cert_manager_api
+from vgscli.cli import create_account_mgmt_api, create_vault_mgmt_api
+from vgscli.cli.types import ResourceId, ResourceIdParamType
+from vgscli.cli_utils import dump_camelized_yaml, iter_entry_points
+from vgscli.errors import ServiceClientListingError, handle_errors
+
+from .apply import wrap_in_http_envelope
+
+
+@with_plugins(iter_entry_points("vgs.get.plugins"))
+@click.group("get")
+def get() -> None:
+    """
+    Get VGS resource.
+    """
+    pass
+
+
+@get.command("service-accounts")
+@click.option(
+    "-O",
+    "--organization",
+    "org_id",
+    type=ResourceIdParamType(prefix="AC"),
+    help="Organization ID which service accounts will be listed",
+)
+@click.pass_context
+@handle_errors()
+def get_service_accounts(ctx: click.Context, org_id: ResourceId):
+    """
+    Get service accounts from the organization.
+    """
+
+    account_mgmt = create_account_mgmt_api(ctx)
+    try:
+        # noinspection PyUnresolvedReferences
+        response = account_mgmt.service_accounts.get(org_id.base58)
+    except (ClientError, ServerError) as e:
+        raise ServiceClientListingError(e)
+
+    accounts = response.body["data"]["attributes"]["service_accounts"]
+
+    for account in accounts:
+        click.echo("---")
+        click.echo(
+            dump_camelized_yaml(
+                {
+                    "apiVersion": "1.0.0",
+                    "kind": "ServiceAccount",
+                    "data": account,
+                }
+            )
+        )
+
+
+@get.command("access-credentials")
+@click.option("--vault", "-V", help="Vault ID", required=True)
+@click.pass_context
+@handle_errors()
+def get_access_credentials(ctx, vault):
+    """
+    Get access-credentials
+    """
+
+    account_mgmt = create_account_mgmt_api(ctx)
+
+    response = account_mgmt.vaults.get_by_id(vault)
+
+    vault_mgmt = create_vault_mgmt_api(
+        ctx, response.body["data"][0]["links"]["vault_management_api"]
+    )
+
+    response = vault_mgmt.credentials.list(headers={"VGS-Tenant": vault})
+
+    click.echo(
+        dump_camelized_yaml(
+            {
+                "apiVersion": "1.0.0",
+                "kind": "AccessCredentials",
+                "data": response.body["data"],
+            }
+        )
+    )
+
+
+@get.command("organizations")
+@click.pass_context
+@handle_errors()
+def get_organizations(ctx):
+    """
+    Get organizations
+    """
+
+    account_mgmt = create_account_mgmt_api(ctx)
+
+    response = account_mgmt.organizations.list()
+
+    click.echo(
+        dump_camelized_yaml(
+            {
+                "apiVersion": "1.0.0",
+                "kind": "Organizations",
+                "data": response.body["data"],
+            }
+        )
+    )
+
+
+@get.command("vaults")
+@click.pass_context
+@handle_errors()
+def get_vaults(ctx):
+    """
+    Get vaults
+    """
+
+    account_mgmt = create_account_mgmt_api(ctx)
+
+    response = account_mgmt.vaults.list()
+
+    click.echo(
+        dump_camelized_yaml(
+            {
+                "apiVersion": "1.0.0",
+                "kind": "Vaults",
+                "data": response.body["data"],
+            }
+        )
+    )
+
+
+@get.command("http-routes")
+@click.option("--vault", "-V", help="Vault ID", required=True)
+@click.pass_context
+@handle_errors()
+def get_http_routes(ctx, vault):
+    """
+    Get HTTP routes
+    """
+
+    handshake(ctx, ctx.obj.env)
+
+    vault_management_api = create_vault_mgmt_api_routes(
+        ctx, vault, ctx.obj.env, token_util.get_access_token()
+    )
+
+    response = vault_management_api.routes.list()
+    routes = normalize(response.body["data"])
+
+    # for each route, wrap in envelope and return
+    wrapped = [wrap_in_http_envelope(route) for route in routes]
+
+    click.echo(yaml.dump_all(wrapped, indent=2))
+
+
+@get.command("routes")
+@click.option("--vault", "-V", help="Vault ID", required=True)
+@click.pass_context
+@handle_errors()
+def get_routes(ctx, vault):
+    """
+    Get routes
+    """
+    handshake(ctx, ctx.obj.env)
+
+    routes_api = create_vault_mgmt_api_routes(
+        ctx, vault, ctx.obj.env, token_util.get_access_token()
+    )
+    dump = dump_all_routes(routes_api)
+    click.echo(dump)
+
+
+@get.command("certificates")
+@click.option("--vault", "-V", help="Vault ID", required=True)
+@click.pass_context
+@handle_errors()
+def get_certificates(ctx, vault):
+    """
+    Get certificates for a vault.
+    """
+    token = token_util.get_access_token()
+    cert_api = create_cert_manager_api(vault, ctx.obj.env, token)
+    response = cert_api.certificates.list(params={"vault_identifier": vault})
+    click.echo(
+        dump_camelized_yaml(
+            {
+                "apiVersion": "1.0.0",
+                "kind": "Certificates",
+                "data": response.body,
+            }
+        )
+    )

vgscli/cli/types/__init__.py

@@ -0,0 +1,2 @@
+from .resource_id import ResourceId, ResourceIdParamType
+from .variable import Variable, VariableParamType

vgscli/cli/types/resource_id.py

@@ -0,0 +1,39 @@
+import click
+
+from vgscli.id_generator import base58_to_uuid, uuid_to_base58
+
+
+class ResourceId:
+    """
+    ID of a VGS resource as shown on the dashboard (e.g., ACtELxZxTcXrAMk2Gp8Qp5yh).
+    """
+
+    def __init__(self, prefix: str, uuid_string: str):
+        self.uuid = uuid_string
+        self._base58 = uuid_to_base58(uuid_string, prefix)
+
+    @property
+    def base58(self) -> str:
+        return self._base58
+
+    @staticmethod
+    def decode_base58(prefix: str, base58_string: str) -> "ResourceId":
+        uuid_string = base58_to_uuid(base58_string)
+        return ResourceId(prefix, uuid_string)
+
+
+class ResourceIdParamType(click.ParamType):
+    name = "resource_id"
+
+    def __init__(self, **kwargs):
+        self.prefix = kwargs.get("prefix", "")
+
+    def convert(self, value: str, param, ctx) -> ResourceId:
+        try:
+            if value.startswith(self.prefix):
+                base58_string = value[len(self.prefix) :]
+                return ResourceId.decode_base58(self.prefix, base58_string)
+
+            return ResourceId(self.prefix, value)
+        except ValueError:
+            self.fail(f"{value!r} is not a valid organization ID", param, ctx)

vgscli/cli/types/variable.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+import click
+
+
+class Variable:
+    """
+    A parsed "name=value" pair.
+    """
+
+    def __init__(self, name: str, value: Any):
+        self.name = name
+        self.value = value
+
+
+class VariableParamType(click.ParamType):
+    name = "name=value"
+
+    def convert(self, value: str, param, ctx) -> Variable:
+        tokens = value.split("=", 2)
+        return Variable(tokens[0], tokens[1])

vgscli/cli_utils.py

@@ -0,0 +1,132 @@
+import logging
+import os
+import uuid
+from collections import OrderedDict
+from importlib.metadata import entry_points
+
+import humps
+import jsonschema
+import yaml
+from vgs.sdk.serializers import dump_yaml
+from vgs.sdk.utils import read_file
+
+from vgscli.errors import NoSuchFileOrDirectoryError, SchemaValidationError
+from vgscli.id_generator import uuid_to_base58
+
+logger = logging.getLogger(__name__)
+
+
+def dump_camelized_yaml(payload):
+    """
+    Transform snake_case to camelCase and dump as a yaml document.
+    """
+    return dump_yaml(OrderedDict(humps.camelize(payload))).rstrip()
+
+
+def validate_yaml(file, schema_path, schema_root=os.path.dirname(__file__)):
+    """
+    Validates the file against the schema.
+
+    Parameters
+    ----------
+    file: is the buffered content of the file
+    schema_path: is the path relative to the working directory
+    schema_root: was added to enable validating from different working directories like vgs-admin-cli-plugin
+    """
+    try:
+        schema = read_file(schema_path, schema_root)
+        file_content = yaml.full_load(file.read())
+
+        jsonschema.validate(file_content, yaml.full_load(schema))
+
+        return file_content
+    except jsonschema.exceptions.ValidationError as e:
+        raise SchemaValidationError(str(e))
+
+
+def validate_multi_yaml(file_to_validate, path_to_schema):
+    schema_file = read_file(path_to_schema, os.path.dirname(__file__))
+    file_content = yaml.load_all(file_to_validate.read(), Loader=yaml.FullLoader)
+    schemas = list(yaml.load_all(schema_file, Loader=yaml.FullLoader))
+    for file in file_content:
+        if not file:
+            logger.debug("Skipping blank file")
+            continue
+        failures = [
+            x for x in [fails_validation(file, schema) for schema in schemas] if x
+        ]
+        if len(failures) == len(schemas):
+            for failure in failures:
+                logger.exception(failure)
+            raise SchemaValidationError(
+                f"Failed to validate {file['apiVersion']} {file['kind']} {file['metadata']['name']} against any known schema."
+            )
+        logger.debug(
+            f"Validated {file['apiVersion']} {file['kind']} {file['metadata']['name']}"
+        )
+        yield file
+
+
+def fails_validation(file, schema):
+    logger.info(
+        f"Validating version={file['apiVersion']} kind={file['kind']} name={file['metadata']['name']}\nagainst\n\t{schema}"
+    )
+    try:
+        jsonschema.validate(file, schema)
+    except jsonschema.exceptions.ValidationError as ex:
+        return ex
+    return None
+
+
+def read_file(file_path, file_root=os.path.dirname(__file__)):
+    full_path = os.path.join(file_root, file_path)
+    try:
+        with open(full_path, "r") as f:
+            schema = f.read()
+            f.close()
+            return schema
+    except FileNotFoundError:
+        raise NoSuchFileOrDirectoryError(full_path)
+
+
+def is_valid_uuid(uuid_to_test, version=4):
+    """
+    Check if uuid_to_test is a valid UUID.
+
+    Parameters
+    ----------
+    uuid_to_test : str
+    version : {1, 2, 3, 4}
+
+    Returns
+    -------
+    `True` if uuid_to_test is a valid UUID, otherwise `False`.
+
+    Examples
+    --------
+    >>> is_valid_uuid('c9bf9e57-1685-4c89-bafb-ff5af830be8a')
+    True
+    >>> is_valid_uuid('c9bf9e58')
+    False
+    """
+    # noinspection PyBroadException
+    try:
+        uuid_obj = uuid.UUID(uuid_to_test, version=version)
+    except Exception:
+        return False
+
+    return str(uuid_obj) == uuid_to_test
+
+
+def format_org_id(org_id):
+    if is_valid_uuid(org_id):
+        org_id = uuid_to_base58(org_id, "AC")
+    return org_id
+
+
+def iter_entry_points(group):
+    eps = entry_points()
+    if hasattr(eps, "select"):
+        return eps.select(group=group)
+    else:
+        return [ep for ep in eps.get(group, [])]

vgscli/click_extensions.py

@@ -0,0 +1,88 @@
+from datetime import datetime, timedelta
+
+import click
+
+
+class Config(object):
+    def __init__(self, debug, env):
+        self.debug = debug
+        self.env = env
+
+
+# https://gist.github.com/jacobtolar/fb80d5552a9a9dfc32b12a829fa21c0c#file-click_mutually_exclusive_argument-py-L4
+class MutuallyExclusiveOption(click.Option):
+    def __init__(self, *args, **kwargs):
+        self.mutually_exclusive = set(kwargs.pop("mutually_exclusive", []))
+        help_cmd = kwargs.get("help", "")
+        if self.mutually_exclusive:
+            ex_str = ", ".join(self.mutually_exclusive)
+            kwargs["help"] = help_cmd + (
+                " NOTE: This argument is mutually exclusive with "
+                " arguments: [" + ex_str + "]."
+            )
+        super(MutuallyExclusiveOption, self).__init__(*args, **kwargs)
+
+    def handle_parse_result(self, ctx, opts, args):
+        if self.mutually_exclusive.intersection(opts) and self.name in opts:
+            raise click.UsageError(
+                "Illegal usage: `{}` is mutually exclusive with "
+                "arguments `{}`.".format(self.name, ", ".join(self.mutually_exclusive))
+            )
+
+        return super(MutuallyExclusiveOption, self).handle_parse_result(ctx, opts, args)
+
+
+class Duration(click.ParamType):
+    name = "duration"
+
+    def convert(self, value, param, ctx):
+        try:
+            delta_unites = {"h": "hours", "m": "minutes", "s": "seconds"}
+            unit = delta_unites[value[-1:].lower()]
+            amount = int(value[:-1])
+            delta_options = {unit: amount}
+            return (datetime.utcnow() - timedelta(**delta_options)).strftime(
+                "%Y-%m-%dT%H:%M:%S"
+            )
+        except TypeError:
+            self.fail(
+                "expected string for int() conversion, got "
+                f"{value!r} of type {type(value).__name__}",
+                param,
+                ctx,
+            )
+        except ValueError:
+            self.fail(f"{value!r} is not a valid integer", param, ctx)
+        except KeyError:
+            self.fail("Only integers that end with h, m or s are allowed", param, ctx)
+
+
+DURATION = Duration()
+
+
+class DateTimeDuration(click.ParamType):
+    name = "dateduration"
+
+    def __init__(self, formats=None):
+        self.formats = formats or ["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M:%S"]
+
+    @staticmethod
+    def _try_to_parse_date(value, pattern):
+        try:
+            return datetime.strptime(value, pattern)
+        except ValueError:
+            return None
+
+    def convert(self, value, param, ctx):
+        for pattern in self.formats:
+            if self._try_to_parse_date(value, pattern):
+                return value
+
+        if len(str(value)) > 7:
+            return self.fail(
+                "invalid date format: {}. (choose from {})".format(
+                    value, ", ".join(self.formats)
+                )
+            )
+
+        return DURATION.convert(value, param, ctx)

vgscli/config_file.py

@@ -0,0 +1,58 @@
+import functools
+import os
+
+import click
+import configobj
+
+APP_DIR = click.get_app_dir("vgs", force_posix=True)
+OPTION_NAME = "--config"
+
+
+class ConfigObjProvider:
+    """
+    When invoked, reads a config file and returns its content as a dictionary.
+    """
+
+    def __init__(self, section=None):
+        self.section = section
+
+    def __call__(self, *args, **kwargs):
+        config = configobj.ConfigObj(args[0])
+        if self.section:
+            config = config[self.section] if self.section in config else {}
+        return config
+
+
+# noinspection PyUnusedLocal
+def callback(provider, ctx: click.Context, param: click.Parameter, value: str):
+    """
+    Change the execution flow to populate the default map first.
+    """
+    ctx.default_map = ctx.default_map or {}
+
+    if value:
+        try:
+            config = provider(value)
+        except Exception as cause:
+            raise click.BadOptionUsage(
+                OPTION_NAME, f"Failed to read configuration file: {cause}", ctx
+            )
+        ctx.default_map.update(config)
+
+    return value
+
+
+def configuration_option(section=None):
+    def decorator(f):
+        return click.option(
+            OPTION_NAME,
+            callback=functools.partial(callback, ConfigObjProvider(section)),
+            default=os.path.join(APP_DIR, "config"),
+            envvar="VGS_CONFIG_FILE",
+            expose_value=False,
+            help="Read configuration from FILE.",
+            is_eager=True,
+            type=click.Path(dir_okay=False),
+        )(f)
+
+    return decorator