cortexapps-cli 0.26.7__py3-none-any.whl → 1.0.0__py3-none-any.whl

cortexapps_cli/cli.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+
+import typer
+from typing_extensions import Annotated
+
+import os
+import sys
+import importlib.metadata
+import tomllib
+import configparser
+import logging
+
+from cortexapps_cli.cortex_client import CortexClient
+
+import cortexapps_cli.commands.api_keys as api_keys
+import cortexapps_cli.commands.audit_logs as audit_logs
+import cortexapps_cli.commands.backup as backup
+import cortexapps_cli.commands.catalog as catalog
+import cortexapps_cli.commands.custom_data as custom_data
+import cortexapps_cli.commands.custom_events as custom_events
+import cortexapps_cli.commands.custom_metrics as custom_metrics
+import cortexapps_cli.commands.dependencies as dependencies
+import cortexapps_cli.commands.deploys as deploys
+import cortexapps_cli.commands.discovery_audit as discovery_audit
+import cortexapps_cli.commands.docs as docs
+import cortexapps_cli.commands.entity_types as entity_types
+import cortexapps_cli.commands.gitops_logs as gitops_logs
+import cortexapps_cli.commands.groups as groups
+import cortexapps_cli.commands.initiatives as initiatives
+import cortexapps_cli.commands.integrations as integrations
+import cortexapps_cli.commands.ip_allowlist as ip_allowlist
+import cortexapps_cli.commands.on_call as on_call
+import cortexapps_cli.commands.packages as packages
+import cortexapps_cli.commands.plugins as plugins
+import cortexapps_cli.commands.queries as queries
+import cortexapps_cli.commands.rest as rest
+import cortexapps_cli.commands.scim as scim
+import cortexapps_cli.commands.scorecards as scorecards
+import cortexapps_cli.commands.teams as teams
+import cortexapps_cli.commands.workflows as workflows
+
+app = typer.Typer(
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    context_settings={"help_option_names": ["-h", "--help"]}
+)
+
+# add subcommands
+app.add_typer(api_keys.app, name="api-keys")
+app.add_typer(audit_logs.app, name="audit-logs")
+app.add_typer(backup.app, name="backup")
+app.add_typer(catalog.app, name="catalog")
+app.add_typer(custom_data.app, name="custom-data")
+app.add_typer(custom_events.app, name="custom-events")
+app.add_typer(custom_metrics.app, name="custom-metrics")
+app.add_typer(dependencies.app, name="dependencies")
+app.add_typer(deploys.app, name="deploys")
+app.add_typer(discovery_audit.app, name="discovery-audit")
+app.add_typer(docs.app, name="docs")
+app.add_typer(entity_types.app, name="entity-types")
+app.add_typer(gitops_logs.app, name="gitops-logs")
+app.add_typer(groups.app, name="groups")
+app.add_typer(initiatives.app, name="initiatives")
+app.add_typer(integrations.app, name="integrations")
+app.add_typer(ip_allowlist.app, name="ip-allowlist")
+app.add_typer(on_call.app, name="on-call")
+app.add_typer(packages.app, name="packages")
+app.add_typer(plugins.app, name="plugins")
+app.add_typer(queries.app, name="queries")
+app.add_typer(rest.app, name="rest")
+app.add_typer(scim.app, name="scim")
+app.add_typer(scorecards.app, name="scorecards")
+app.add_typer(teams.app, name="teams")
+app.add_typer(workflows.app, name="workflows")
+
+# global options
+@app.callback()
+def global_callback(
+    ctx: typer.Context,
+    api_key: str = typer.Option(None, "--api-key", "-k", help="API key", envvar="CORTEX_API_KEY"),
+    url: str = typer.Option("https://api.getcortexapp.com", "--url", "-u", help="Base URL for the API", envvar="CORTEX_BASE_URL"),
+    config_file: str = typer.Option(os.path.join(os.path.expanduser('~'), '.cortex', 'config'), "--config", "-c", help="Config file path", envvar="CORTEX_CONFIG"),
+    tenant: str = typer.Option("default", "--tenant", "-t", help="Tenant alias", envvar="CORTEX_TENANT_ALIAS"),
+    log_level: Annotated[str, typer.Option("--log-level", "-l", help="Set the logging level")] = "INFO"
+):
+    if not ctx.obj:
+        ctx.obj = {}
+
+    numeric_level = getattr(logging, log_level.upper(), None)
+    if not isinstance(numeric_level, int):
+        raise ValueError(f"Invalid log level: {log_level}")
+
+    if not os.path.isfile(config_file):
+        # no config file found
+        if not api_key:
+            raise typer.BadParameter("No API key provided and no config file found")
+        create_config = False
+
+        # check if we are in a terminal, if so, ask the user if they want to create a config file
+        if sys.stdin.isatty() and sys.stdout.isatty():
+            create_config = typer.confirm("No config file found. Do you want to create one?")
+
+        if create_config:
+            os.makedirs(os.path.dirname(config_file), exist_ok=True)
+            with open(config_file, "w") as f:
+                f.write(f"[{tenant}]\n")
+                f.write(f"api_key = {api_key}\n")
+                f.write(f"base_url = {url}\n")
+    else:
+        # config file found
+        # if api_key is provided, use that in preference to the config file
+        if not api_key:
+            config = configparser.ConfigParser()
+            config.read(config_file)
+            if tenant not in config:
+                raise typer.BadParameter(f"Tenant {tenant} not found in config file")
+            api_key = config[tenant]["api_key"]
+            if url not in config[tenant]:
+                url = url
+            else:
+                url = config[tenant]["base_url"]
+
+    # strip any quotes or spaces from the api_key and url
+    api_key = api_key.strip('"\' ')
+    url = url.strip('"\' /')
+
+    ctx.obj["client"] = CortexClient(api_key, tenant, numeric_level, url)
+
+@app.command()
+def version():
+
+    """
+    Show the version and exit.
+    """
+    try:
+        with open("pyproject.toml", "rb") as f:
+            pyproject = tomllib.load(f)
+        version = pyproject["tool"]["poetry"]["version"]
+    except Exception as e:
+        version = importlib.metadata.version('cortexapps_cli')
+    print(version)
+
+if __name__ == "__main__":
+    app()

cortexapps_cli/command_options.py

@@ -0,0 +1,43 @@
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+
+class ListCommandOptions:
+    table_output = Annotated[
+        Optional[bool],
+        typer.Option("--table", help="Output the response as a table", show_default=False)  # , callback=table_output_cb)
+    ]
+    csv_output = Annotated[
+        Optional[bool],
+        typer.Option("--csv", help="Output the response as CSV", show_default=False)  # , callback=csv_output_cb)
+    ]
+    columns = Annotated[
+        Optional[List[str]],
+        typer.Option("--columns", "-C", help="Columns to include in the table, in the format HeaderName=jsonpath", show_default=False)
+    ]
+    filters = Annotated[
+        Optional[List[str]],
+        typer.Option("--filter", "-F", help="Filters to apply on rows, in the format jsonpath=regex", show_default=False)
+    ]
+    no_headers = Annotated[
+        Optional[bool],
+        typer.Option("--no-headers", help="For csv output type only: don't print header columns.", show_default=False)
+    ]
+    sort = Annotated[
+        Optional[List[str]],
+        typer.Option("--sort", "-S", help="Sort order to apply on rows, in the format jsonpath:asc or jsonpath:desc", show_default=False)
+    ]
+    page = Annotated[
+        Optional[int],
+        typer.Option("--page", "-p", help="Page number to return, 0 indexed - omit to fetch all pages", show_default=False)
+    ]
+    page_size = Annotated[
+        Optional[int],
+        typer.Option("--page-size", "-z", help="Page size for results", show_default=False)
+    ]
+
+class CommandOptions:
+    _print = Annotated[
+        Optional[bool],
+        typer.Option("--print", help="If result should be printed to the terminal", hidden=True)
+    ]

cortexapps_cli/commands/api_keys.py

@@ -0,0 +1,152 @@
+from datetime import datetime
+import typer
+import json
+from enum import Enum
+from typing_extensions import Annotated
+from cortexapps_cli.utils import print_output_with_context
+from cortexapps_cli.command_options import CommandOptions
+from cortexapps_cli.command_options import ListCommandOptions
+
+app = typer.Typer(
+    help="API Keys commands",
+    no_args_is_help=True
+)
+
+class DefaultRole(str, Enum):
+    ADMIN = "ADMIN"
+    USER = "USER"
+    READ_ONLY = "READ_ONLY"
+
+@app.command()
+def list(
+    ctx: typer.Context,
+    page: ListCommandOptions.page = None,
+    page_size: ListCommandOptions.page_size = 250,
+    table_output: ListCommandOptions.table_output = False,
+    csv_output: ListCommandOptions.csv_output = False,
+    columns: ListCommandOptions.columns = [],
+    no_headers: ListCommandOptions.no_headers = False,
+    filters: ListCommandOptions.filters = [],
+    sort: ListCommandOptions.sort = [],
+):
+    """
+    List API keys. The API key used to make the request must have the Edit API keys permission.
+    """
+
+    client = ctx.obj["client"]
+
+    params = {
+       "page": page,
+       "pageSize": page_size
+    }       
+
+    if (table_output or csv_output) and not ctx.params.get('columns'):
+        ctx.params['columns'] = [
+            "CID=cid",
+            "Name=name",
+            "Last4=last4",
+            "Description=description",
+            "Roles=roles",
+            "CreatedDate=createdDate",
+            "ExpirationDate=expirationDate",
+        ]
+
+    # remove any params that are None
+    params = {k: v for k, v in params.items() if v is not None}
+    
+    if page is None:
+        r = client.fetch("api/v1/auth/key", params=params)
+    else:
+        r = client.get("api/v1/auth/key", params=params)
+    print_output_with_context(ctx, r)
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    description: str | None = typer.Option(None, "--description", "-d", help="Description of the API key"),
+    name: str | None = typer.Option(None, "--name", "-n", help="Name of the API key"),
+    file_input: Annotated[typer.FileText, typer.Option("--file", "-f", help=" File containing content; can be passed as stdin with -, example: -f-")] = None,
+    default_roles: str | None  = typer.Option(None, "--default-roles", "-dr", help="Comma-separated list of default roles (only if file input not provided."),
+    custom_roles: str | None  = typer.Option(None, "--custom-roles", "-cr", help="Comma-separated list of custom roles (only if file input not provided."),
+    expiration_date: datetime | None = typer.Option(None, "--expiration-date", "-e", help="Expiration date of the API key", formats=["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%dT%H:%M"]),
+):
+    """
+    Create new API key.  The API key used to make the request must have the Create API keys permission
+    """
+    client = ctx.obj["client"]
+
+    if file_input:
+        if name or description or expiration_date or default_roles or custom_roles:
+            raise typer.BadParameter("When providing an API definition file, do not specify any other attributes")
+        data = json.loads("".join([line for line in file_input]))
+    else:
+        if not default_roles and not custom_roles:
+            raise typer.BadParameter("One of default-roles or custom-roles is required")
+
+        data = {
+           "roles": [],
+           "name": name
+        }
+
+        if default_roles is not None:
+            for role in default_roles.split(","):
+                data["roles"].append({"role": role, "type": "DEFAULT"})
+        if custom_roles is not None:
+            for role in custom_roles.split(","):
+                data["roles"].append({"tag": role, "type": "CUSTOM"})
+
+        if description:
+            data["description"] = description
+        if expiration_date:
+            data["expirationDate"] = expiration_date.strftime('%Y-%m-%dT%H:%M:%S.000Z')
+
+    r = client.post("api/v1/auth/key", data=data)
+    print_output_with_context(ctx, r)
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    cid: str = typer.Option(..., "--cid", "-c", help="The unique, auto-generated identifier for the API key"),
+    description: str | None = typer.Option(None, "--description", "-d", help="Description of the API key"),
+    name: str = typer.Option(..., "--name", "-n", help="Name of the API key"),
+):
+    """
+    Update API key.  The API key used to make the request must have the Edit API keys permission.
+    """
+    client = ctx.obj["client"]
+
+    data = {
+       "name": name
+    }
+    if description is not None:
+        data["description"] = description
+
+    r = client.put("api/v1/auth/key/" + cid, data=data)
+    print_output_with_context(ctx, r)
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    cid: str = typer.Option(..., "--cid", "-c", help="The unique, auto-generated identifier for the API key"),
+):
+    """
+    Get API key.
+    """
+
+    client = ctx.obj["client"]
+    
+    r = client.get("api/v1/auth/key/"+ cid)
+    print_output_with_context(ctx, r)
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    cid: str = typer.Option(..., "--cid", "-c", help="The unique, auto-generated identifier for the API key"),
+):
+    """
+    Delete API key.
+    """
+
+    client = ctx.obj["client"]
+    
+    r = client.delete("api/v1/auth/key/"+ cid)

cortexapps_cli/commands/audit_logs.py

@@ -0,0 +1,97 @@
+from datetime import datetime
+from enum import Enum
+import typer
+from cortexapps_cli.command_options import ListCommandOptions
+from cortexapps_cli.utils import print_output_with_context, print_output
+
+app = typer.Typer(
+    help="Audit log commands",
+    no_args_is_help=True
+)
+
+class Action(str, Enum):
+    CREATE = "CREATE"
+    DELETE = "DELETE"
+    UPDATE = "UPDATE"
+
+class ActorType(str, Enum):
+    ANONYMOUS = "ANONYMOUS"
+    API_KEY = "API_KEY"
+    BACKSTAGE = "BACKSTAGE"
+    OAUTH2 = "OAUTH2"
+    PERSONAL_API_KEY = "PERSONAL_API_KEY"
+
+class ActorRequestType(str, Enum):
+    API_KEY_ENTITY = "API_KEY_ENTITY"
+    ATLASSIAN_WEBHOOK = "ATLASSIAN_WEBHOOK"
+    SCORECARD_BADGES = "SCORECARD_BADGES"
+    SLACK_COMMAND = "SLACK_COMMAND"
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    actions: list[Action] | None = typer.Option(None, "--actions", "-a", help="The audit action"),
+    actorApiKeyIdentifiers: list[str] | None = typer.Option(None, "--actorApiKeyIdentifiers", "-ak", help="API key name associated with audit event"),
+    actorEmails: list[str] | None = typer.Option(None, "--actorEmails", "-ae", help="Email address associated with audit event"),
+    actorIpAddresses: list[str] | None = typer.Option(None, "--actorIpAddresses", "-ai", help="Source IP Addresses associated with audit event"),
+    actorRequestTypes: list[ActorRequestType] | None = typer.Option(None, "--actorRequestTypes", "-ar", help="Request event associated with audit event"),
+    actorTypes: list[ActorType] | None = typer.Option(None, "--actorTypes", "-at", help="Actor that triggered the audit event"),
+    end_time: datetime = typer.Option(None, "--end-time", "-e", help="End time of audit logs to retrieve", formats=["%Y-%m-%dT%H:%M:%S", "%Y-%m-%dT%H:%M"]),
+    objectIdentifiers: list[str] | None = typer.Option(None, "--objectIdentifiers", "-oi", help="The name of the Cortex object that was modified, ie x-cortex-tag value, metadata field name, etc."),
+    objectTypes: list[str] | None = typer.Option(None, "--objectTypes", "-ot", help="ObjectTypes"),
+    start_time: datetime = typer.Option(None, "--start-time", "-s", help="Start time of audit logs to retrieve", formats=["%Y-%m-%dT%H:%M:%S", "%Y-%m-%dT%H:%M"]),
+    page: ListCommandOptions.page = None,
+    page_size: ListCommandOptions.page_size = 250,
+    table_output: ListCommandOptions.table_output = False,
+    csv_output: ListCommandOptions.csv_output = False,
+    columns: ListCommandOptions.columns = [],
+    no_headers: ListCommandOptions.no_headers = False,
+    filters: ListCommandOptions.filters = [],
+    sort: ListCommandOptions.sort = [],
+):
+    """
+    Note: To see the complete list of possible values, please reference the available filter options for audit logs under Settings in the app.
+    """
+    client = ctx.obj["client"]
+
+    params = {
+        "actions": actions,
+        "actorApiKeyIdentifiers": actorApiKeyIdentifiers,
+        "actorEmails": actorEmails,
+        "actorIpAddresses": actorIpAddresses,
+        "actorRequestTypes": actorRequestTypes,
+        "actorTypes": actorTypes,
+        "endTime": end_time,
+        "objectIdentifiers": objectIdentifiers,
+        "objectTypes": objectTypes,
+        "page": page,
+        "pageSize": page_size,
+        "startTime": start_time
+    }
+
+    # remove any params that are None
+    params = {k: v for k, v in params.items() if v is not None}
+
+    # convert datetime and list types to string
+    for k, v in params.items():
+        if str(type(v)) == "<class 'datetime.datetime'>":
+           params[k] = v.strftime('%Y-%m-%dT%H:%M:%S')
+        if str(type(v)) == "<class 'list'>":
+            params[k] = ','.join(v)
+
+    if (table_output or csv_output) and not ctx.params.get('columns'):
+        ctx.params['columns'] = [
+            "Action=action",
+            "ObjectType=objectType",
+            "ActorIdentifier=actorIdentifier",
+            "ObjectIdentifier=objectIdentifier",
+            "IpAddress=ipAddress",
+            "Timestamp=timestamp",
+        ]
+    
+    if page is None:
+        r = client.fetch("api/v1/audit-logs", params=params)
+    else:
+        r = client.get("api/v1/audit-logs", params=params)
+
+    print_output_with_context(ctx, r)