robusta-api 0.0.0__py3-none-any.whl

robusta/_version.py

@@ -0,0 +1,2 @@
+# this is updated by .github/workflows/release.yaml
+__version__ = "0.0.0"

robusta/api/__init__.py

@@ -0,0 +1,330 @@
+from hikaru.model.rel_1_26 import Container, DaemonSet, Deployment, Pod, ReplicaSet, StatefulSet, Volume
+
+from robusta.core.discovery.discovery import (
+    extract_containers_k8,
+    extract_ready_pods,
+    extract_total_pods,
+    extract_volumes_k8,
+    is_pod_finished,
+    is_release_managed_by_helm,
+    should_report_pod,
+)
+from robusta.core.discovery.resource_names import ResourceNameLister
+from robusta.core.model.base_params import (
+    ActionParams,
+    AlertResourceGraphEnricherParams,
+    BashParams,
+    ChartValuesFormat,
+    CustomGraphEnricherParams,
+    EventEnricherParams,
+    FindingKeyParams,
+    GrafanaAnnotationParams,
+    GrafanaParams,
+    LogEnricherParams,
+    NamedRegexPattern,
+    PodResourceGraphEnricherParams,
+    PodRunningParams,
+    ProcessParams,
+    PrometheusDateRange,
+    PrometheusDuration,
+    PrometheusParams,
+    PrometheusQueryParams,
+    RateLimitParams,
+    ResourceChartItemType,
+    ResourceChartResourceType,
+    ResourceGraphEnricherParams,
+    OOMGraphEnricherParams,
+    OomKillParams,
+    TimedPrometheusParams,
+    VideoEnricherParams,
+)
+from robusta.core.model.env_vars import (
+    CLUSTER_DOMAIN,
+    CLUSTER_STATUS_PERIOD_SEC,
+    CUSTOM_PLAYBOOKS_ROOT,
+    DEFAULT_PLAYBOOKS_PIP_INSTALL,
+    DEFAULT_PLAYBOOKS_ROOT,
+    DEFAULT_TIMEZONE,
+    DISCORD_TABLE_COLUMNS_LIMIT,
+    DISCOVERY_PERIOD_SEC,
+    ENABLE_TELEMETRY,
+    FLOAT_PRECISION_LIMIT,
+    GIT_MAX_RETRIES,
+    GRAFANA_READ_TIMEOUT,
+    GRAFANA_RENDERER_URL,
+    IMAGE_REGISTRY,
+    INCOMING_EVENTS_QUEUE_MAX_SIZE,
+    INCOMING_REQUEST_TIME_WINDOW_SECONDS,
+    INSTALLATION_NAMESPACE,
+    INTERNAL_PLAYBOOKS_ROOT,
+    NUM_EVENT_THREADS,
+    PLAYBOOKS_CONFIG_FILE_PATH,
+    PLAYBOOKS_ROOT,
+    PORT,
+    PRINTED_TABLE_MAX_WIDTH,
+    PROMETHEUS_ENABLED,
+    PROMETHEUS_REQUEST_TIMEOUT_SECONDS,
+    RELAY_EXTERNAL_ACTIONS_URL,
+    RELEASE_NAME,
+    RESOURCE_UPDATES_CACHE_TTL_SEC,
+    ROBUSTA_LOGO_URL,
+    ROBUSTA_TELEMETRY_ENDPOINT,
+    ROBUSTA_UI_DOMAIN,
+    RUNNER_SERVICE_ACCOUNT,
+    RUNNER_VERSION,
+    SEND_ADDITIONAL_TELEMETRY,
+    SERVICE_CACHE_MAX_SIZE,
+    SERVICE_CACHE_TTL_SEC,
+    SLACK_TABLE_COLUMNS_LIMIT,
+    TEAMS_IMAGE_WIDTH,
+    TELEMETRY_PERIODIC_SEC,
+    TRACE_INCOMING_REQUESTS,
+    WEBSOCKET_PING_INTERVAL,
+    WEBSOCKET_PING_TIMEOUT,
+)
+from robusta.core.model.events import ExecutionBaseEvent
+from robusta.core.model.k8s_operation_type import K8sOperationType
+from robusta.core.model.pods import (
+    ContainerResources,
+    PodContainer,
+    PodResources,
+    ResourceAttributes,
+    find_most_recent_oom_killed_container,
+    format_unit,
+    get_oom_kill_time,
+    get_oom_killed_container,
+    is_state_in_oom_status,
+    k8s_memory_factors,
+    pod_limits,
+    pod_most_recent_oom_killed_container,
+    pod_other_requests,
+    pod_requests,
+    pod_resources,
+    pod_restarts,
+)
+from robusta.core.model.services import ContainerInfo, EnvVar, Resources, ServiceConfig, ServiceInfo, VolumeInfo
+from robusta.core.persistency.in_memory import get_persistent_data
+from robusta.core.playbooks.actions_registry import Action, action
+from robusta.core.playbooks.common import get_event_timestamp, get_resource_events, get_resource_events_table
+from robusta.core.playbooks.container_playbook_utils import create_container_graph
+from robusta.core.playbooks.job_utils import CONTROLLER_UID, get_job_all_pods, get_job_latest_pod, get_job_selector
+from robusta.core.playbooks.node_playbook_utils import create_node_graph_enrichment
+from robusta.core.playbooks.pod_utils.crashloop_utils import get_crash_report_enrichments
+from robusta.core.playbooks.pod_utils.imagepull_utils import (
+    get_image_pull_backoff_enrichment,
+    get_image_pull_backoff_container_statuses,
+)
+from robusta.core.playbooks.pod_utils.pending_pod_utils import get_pending_pod_enrichment
+from robusta.core.playbooks.crash_reporter import send_crash_report
+from robusta.core.playbooks.prometheus_enrichment_utils import (
+    XAxisLine,
+    create_chart_from_prometheus_query,
+    create_graph_enrichment,
+    create_resource_enrichment,
+    get_node_internal_ip,
+    run_prometheus_query,
+    run_prometheus_query_range,
+)
+from robusta.core.playbooks.trigger import (
+    BaseTrigger,
+    CustomTriggers,
+    K8sTriggers,
+    PrometheusAlertTriggers,
+    ScheduledTriggers,
+    Trigger,
+)
+from robusta.core.reporting import (
+    BaseBlock,
+    CallbackBlock,
+    CallbackChoice,
+    DividerBlock,
+    Emojis,
+    Enrichment,
+    FileBlock,
+    EmptyFileBlock,
+    Filterable,
+    Finding,
+    FindingSeverity,
+    FindingStatus,
+    FindingSubject,
+    HeaderBlock,
+    JsonBlock,
+    KubernetesDiffBlock,
+    KubernetesFieldsBlock,
+    ListBlock,
+    MarkdownBlock,
+    PrometheusBlock,
+    ScanReportBlock,
+    PopeyeScanReportBlock,
+    KRRScanReportBlock,
+    ScanReportRow,
+    TableBlock,
+    VideoLink,
+)
+
+from robusta.core.reporting.base import EnrichmentType
+from robusta.core.reporting.blocks import GraphBlock
+from robusta.core.reporting.action_requests import (
+    ActionRequestBody,
+    ExternalActionRequest,
+    OutgoingActionRequest,
+    PartialAuth,
+    sign_action_request,
+)
+from robusta.core.reporting.callbacks import ExternalActionRequestBuilder
+from robusta.core.reporting.consts import (
+    EnrichmentAnnotation,
+    FindingAggregationKey,
+    FindingSource,
+    FindingSubjectType,
+    FindingType,
+    ScanType,
+    SlackAnnotations,
+)
+from robusta.core.reporting.custom_rendering import RendererType, charts_style, render_value
+from robusta.core.reporting.finding_subjects import KubeObjFindingSubject, PodFindingSubject
+from robusta.core.schedule.model import (
+    DynamicDelayRepeat,
+    FixedDelayRepeat,
+    JobState,
+    JobStatus,
+    ScheduledJob,
+    SchedulingInfo,
+)
+from robusta.core.playbooks.node_playbook_utils import create_node_graph_enrichment
+from robusta.core.sinks import SinkBase, SinkBaseParams, SinkConfigBase
+from robusta.core.sinks.kafka import KafkaSink, KafkaSinkConfigWrapper, KafkaSinkParams
+from robusta.core.triggers.helm_releases_triggers import HelmReleasesEvent, HelmReleasesTriggerEvent
+from robusta.integrations.argocd.argocd_client import ArgoCDClient
+from robusta.integrations.git.git_repo import ClusterChanges, GitRepo, GitRepoManager, SingleChange
+from robusta.integrations.grafana import Grafana
+from robusta.integrations.kubernetes.api_client_utils import (
+    exec_commands,
+    exec_shell_command,
+    get_pod_logs,
+    list_available_services,
+    parse_kubernetes_datetime,
+    parse_kubernetes_datetime_to_ms,
+    parse_kubernetes_datetime_with_ms,
+    prepare_pod_command,
+    to_kubernetes_name,
+    upload_file,
+    wait_for_pod_status,
+    wait_until,
+    wait_until_job_complete,
+)
+from robusta.integrations.kubernetes.autogenerated.events import (
+    KIND_TO_EVENT_CLASS,
+    LOADERS_MAPPINGS,
+    ClusterRoleAttributes,
+    ClusterRoleBindingAttributes,
+    ClusterRoleBindingChangeEvent,
+    ClusterRoleBindingEvent,
+    ClusterRoleChangeEvent,
+    ClusterRoleEvent,
+    ConfigMapAttributes,
+    ConfigMapChangeEvent,
+    ConfigMapEvent,
+    DaemonSetAttributes,
+    DaemonSetChangeEvent,
+    DaemonSetEvent,
+    DeploymentAttributes,
+    DeploymentChangeEvent,
+    DeploymentEvent,
+    EventAttributes,
+    EventChangeEvent,
+    EventEvent,
+    HorizontalPodAutoscalerAttributes,
+    HorizontalPodAutoscalerChangeEvent,
+    HorizontalPodAutoscalerEvent,
+    JobAttributes,
+    JobChangeEvent,
+    JobEvent,
+    KubernetesAnyChangeEvent,
+    KubernetesResourceEvent,
+    NamespaceAttributes,
+    NamespaceChangeEvent,
+    NamespaceEvent,
+    NodeAttributes,
+    NodeChangeEvent,
+    NodeEvent,
+    PersistentVolumeAttributes,
+    PersistentVolumeChangeEvent,
+    PersistentVolumeEvent,
+    PodAttributes,
+    PodChangeEvent,
+    PodEvent,
+    ReplicaSetAttributes,
+    ReplicaSetChangeEvent,
+    ReplicaSetEvent,
+    ResourceAttributes,
+    ResourceLoader,
+    ServiceAccountAttributes,
+    ServiceAccountChangeEvent,
+    ServiceAccountEvent,
+    ServiceAttributes,
+    ServiceChangeEvent,
+    ServiceEvent,
+    StatefulSetAttributes,
+    StatefulSetChangeEvent,
+    StatefulSetEvent,
+)
+from robusta.integrations.kubernetes.autogenerated.models import VERSION_KIND_TO_MODEL_CLASS, get_api_version
+from robusta.integrations.kubernetes.custom_models import (
+    JobSecret,
+    Process,
+    ProcessList,
+    RegexReplacementStyle,
+    RobustaDeployment,
+    RobustaEvent,
+    RobustaJob,
+    RobustaPod,
+    build_selector_query,
+    does_daemonset_have_toleration,
+    does_node_have_taint,
+    extract_image_list,
+    extract_images,
+    get_images,
+    list_pods_using_selector,
+)
+from robusta.integrations.kubernetes.process_utils import ProcessFinder, ProcessType
+from robusta.integrations.prometheus.models import (
+    SEVERITY_MAP,
+    AlertManagerEvent,
+    PrometheusAlert,
+    PrometheusKubernetesAlert,
+)
+from robusta.integrations.prometheus.utils import (
+    AlertManagerDiscovery,
+    PrometheusDiscovery,
+    ServiceDiscovery,
+    get_prometheus_connect,
+)
+from robusta.integrations.resource_analysis.cpu_analyzer import CpuAnalyzer
+from robusta.integrations.resource_analysis.memory_analyzer import MemoryAnalyzer, pretty_size
+from robusta.integrations.resource_analysis.node_cpu_analyzer import NodeCpuAnalyzer
+from robusta.integrations.scheduled.event import ScheduledExecutionEvent
+from robusta.integrations.scheduled.playbook_scheduler_manager_impl import (
+    PlaybooksSchedulerManagerImpl,
+    ScheduledIntegrationParams,
+)
+from robusta.integrations.scheduled.trigger import DynamicDelayRepeatTrigger, FixedDelayRepeatTrigger
+from robusta.integrations.slack.sender import SlackSender
+from robusta.runner.object_updater import update_item_attr
+from robusta.utils.base64_utils import is_base64_encoded
+from robusta.utils.cluster_provider_discovery import cluster_provider
+from robusta.utils.common import duplicate_without_fields, is_matching_diff
+from robusta.utils.error_codes import ActionException, ErrorCodes
+from robusta.utils.function_hashes import action_hash
+from robusta.utils.parsing import load_json
+from robusta.utils.rate_limiter import RateLimiter
+from robusta.utils.silence_utils import (
+    AddSilenceParams,
+    AlertManagerParams,
+    DeleteSilenceParams,
+    Silence,
+    SilenceOperation,
+    gen_alertmanager_headers,
+    get_alertmanager_url,
+    get_alertmanager_url_path,
+)

robusta/cli/auth.py

@@ -0,0 +1,166 @@
+import base64
+import re
+import subprocess
+import traceback
+import uuid
+from typing import Optional
+
+import click_spinner
+import requests
+import typer
+import yaml
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives.serialization import Encoding, NoEncryption, PrivateFormat, PublicFormat
+from dpath.util import get
+from pydantic import BaseModel
+
+from robusta.cli.backend_profile import backend_profile
+from robusta.cli.playbooks_cmd import NAMESPACE_EXPLANATION, get_playbooks_config
+from robusta.cli.utils import exec_in_robusta_runner_output, namespace_to_kubectl
+
+AUTH_SECRET_NAME = "robusta-auth-config-secret"
+app = typer.Typer(add_completion=False)
+
+
+class RSAKeyPair(BaseModel):
+    prv: str = None
+    pub: str = None
+    private: str = None
+    public: str = None
+
+
+def gen_rsa_pair() -> RSAKeyPair:
+    # generate private/public key pair
+    key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+
+    # get public key in OpenSSH format
+    public_key = key.public_key().public_bytes(Encoding.PEM, PublicFormat.SubjectPublicKeyInfo)
+
+    # get private key in PEM container format
+    pem = key.private_bytes(
+        encoding=Encoding.PEM, format=PrivateFormat.TraditionalOpenSSL, encryption_algorithm=NoEncryption()
+    )
+
+    return RSAKeyPair(public=base64.b64encode(public_key), private=base64.b64encode(pem))
+
+
+def get_existing_auth_config(namespace: str) -> Optional[RSAKeyPair]:
+    try:
+        secret_content = subprocess.check_output(
+            f"kubectl get secret {namespace_to_kubectl(namespace)} {AUTH_SECRET_NAME} -o yaml",
+            shell=True,
+        )
+    except Exception:
+        return None
+
+    auth_secret = yaml.safe_load(secret_content)
+    return RSAKeyPair(
+        prv=base64.b64decode(auth_secret["data"]["prv"]).decode(),
+        pub=base64.b64decode(auth_secret["data"]["pub"]).decode(),
+    )
+
+
+class TokenDetails(BaseModel):
+    pub: str
+    account_id: str
+    user_id: str
+    session_token: str
+    enc_key: str
+    key_id: str
+
+
+def store_server_token(token_details: TokenDetails, debug: bool = False) -> bool:
+    try:
+        response = requests.post(backend_profile.robusta_store_token_url, json=token_details.dict())
+        if debug and response.status_code != 201:
+            typer.secho(f"Failed to store server token. status-code {response.status_code} text {response.text}")
+
+        return response.status_code == 201
+    except Exception:
+        if debug:
+            typer.secho(f"Error trying to store server token. {traceback.format_exc()}")
+        return False
+
+
+def _get_signing_key_from_env_variable(namespace: Optional[str], env_var_name: str) -> str:
+    return str(exec_in_robusta_runner_output(f'echo "${env_var_name}"', namespace), "utf-8").strip()
+
+
+@app.command(name="web-connect")
+@app.command()
+def gen_token(
+    account_id: str = typer.Option(
+        ...,
+        help="Robusta account id",
+    ),
+    user_id: str = typer.Option(..., help="User id for which the token is created"),
+    session_token: str = typer.Option(
+        ...,
+        help="User session token. Created for an authenticated user via the Robusta UI",
+    ),
+    namespace: str = typer.Option(
+        None,
+        help=NAMESPACE_EXPLANATION,
+    ),
+    debug: bool = typer.Option(False),
+):
+    """Generate token required to run actions manually in Robusta UI"""
+    typer.echo("connecting to cluster...")
+    with click_spinner.spinner():
+        auth_config = get_existing_auth_config(namespace)
+
+    if not auth_config:
+        typer.secho(
+            "\nRSA auth isn't configured. "
+            "Please update Robusta and run `robusta update-config` to configure it. Aborting!",
+            fg="red",
+        )
+        return
+
+    playbooks_config = get_playbooks_config(namespace)
+    active_playbooks_file = playbooks_config["data"]["active_playbooks.yaml"]
+    playbooks_config_yaml = yaml.safe_load(active_playbooks_file)
+    signing_key = get(playbooks_config_yaml, "global_config/signing_key", default=None)
+    if not signing_key:
+        typer.secho("signing_key is not defined. Please update Robusta and run `robusta update-config`", fg="red")
+        return
+
+    try:
+        env_match = re.fullmatch(r"\{\{\s*env\.(\S+)\s*}}", signing_key)
+        if env_match:
+            env_var_name = env_match.group(1)
+            typer.secho(f"Fetching secret key from an env var named: {env_var_name}")
+            signing_key = _get_signing_key_from_env_variable(namespace, env_var_name)
+            if not signing_key:
+                typer.secho(f"Could not find an env var named {env_var_name}", fg="red")
+                return
+        signing_key_uuid = uuid.UUID(signing_key)
+    except Exception:
+        typer.secho(
+            "Bad format for signing_key. Please run `robusta update-config` to generate a new valid"
+            " signing_key for your account.",
+            fg="red",
+        )
+        return
+
+    client_enc_key = uuid.uuid4()
+    server_enc_key = uuid.UUID(int=(signing_key_uuid.int ^ client_enc_key.int))
+    key_id = str(uuid.uuid4())
+
+    token_response = TokenDetails(
+        pub=auth_config.pub,
+        account_id=account_id,
+        user_id=user_id,
+        session_token=session_token,
+        enc_key=str(server_enc_key),
+        key_id=key_id,
+    )
+    if not store_server_token(token_response, debug):
+        typer.secho("Failed to store server token. Aborting!", fg="red")
+        return
+
+    # client response is the same, only with a different enc_key
+    token_response.enc_key = str(client_enc_key)
+
+    typer.secho("Token created successfully. Submit it in the Robusta UI", fg="green")
+    typer.secho(base64.b64encode(token_response.json(exclude={"session_token"}).encode("utf-8")).decode())

robusta/cli/backend_profile.py

@@ -0,0 +1,54 @@
+import os
+import sys
+
+import typer
+from pydantic.main import BaseModel
+
+from robusta.cli.utils import host_for_params
+
+ROBUSTA_BACKEND_PROFILE = os.environ.get("ROBUSTA_BACKEND_PROFILE", "")
+
+
+class BackendProfile(BaseModel):
+    robusta_cloud_api_host: str = ""
+    robusta_ui_domain: str = ""
+    robusta_relay_ws_address: str = ""
+    robusta_relay_external_actions_url: str = ""
+    robusta_telemetry_endpoint: str = ""
+    robusta_store_token_url: str = ""
+    custom_profile: bool = False
+
+    @classmethod
+    def fromDomainProvider(
+        cls, domain: str, api_endpoint_prefix: str, platform_endpoint_prefix: str, relay_endpoint_prefix: str
+    ):
+        return cls(
+            robusta_cloud_api_host=host_for_params(api_endpoint_prefix, domain),
+            robusta_ui_domain=host_for_params(platform_endpoint_prefix, domain),
+            robusta_relay_ws_address=host_for_params(relay_endpoint_prefix, domain, "wss"),
+            robusta_relay_external_actions_url=f"{host_for_params(api_endpoint_prefix, domain)}/integrations/generic/actions",
+            robusta_telemetry_endpoint=f"{host_for_params(api_endpoint_prefix, domain)}/telemetry",
+            robusta_store_token_url=f"{host_for_params(api_endpoint_prefix, domain)}/auth/server/tokens",
+        )
+
+
+# default values
+backend_profile = BackendProfile(
+    robusta_cloud_api_host="https://api.robusta.dev",
+    robusta_ui_domain="https://platform.robusta.dev",
+    robusta_store_token_url="https://api.robusta.dev/auth/server/tokens",
+)
+
+if ROBUSTA_BACKEND_PROFILE:
+    typer.secho(
+        f"Using Robusta backend profile: {ROBUSTA_BACKEND_PROFILE}",
+        color="blue",
+    )
+    backend_profile = BackendProfile.parse_file(ROBUSTA_BACKEND_PROFILE)
+    backend_profile.custom_profile = True
+
+    profile_dict = backend_profile.dict()
+    for attribute, val in profile_dict.items():
+        if not profile_dict.get(attribute):
+            typer.secho(f"Illegal profile. Missing {attribute}. Aborting!")
+            sys.exit(1)

robusta/cli/eula.py

@@ -0,0 +1,27 @@
+import requests
+import typer
+
+from robusta.cli.backend_profile import backend_profile
+
+
+def handle_eula(account_id, robusta_api_key, cloud_routing_enabled):
+    require_eula = robusta_api_key or cloud_routing_enabled
+    if not require_eula:
+        return
+
+    while True:
+        eula_url = f"{backend_profile.robusta_cloud_api_host}/eula.html"
+        typer.echo(f"Please read and approve our End User License Agreement: {eula_url}")
+        eula_approved = typer.confirm("Do you accept our End User License Agreement?")
+
+        if eula_approved:
+            try:
+                requests.get(f"{eula_url}?account_id={account_id}")
+            except Exception:
+                typer.echo(f"\nEula approval failed: {eula_url}")
+            return
+
+        typer.secho(
+            "End User License Agreement rejected. Sorry, you must either accept or restart the installation and disable the UI and cloud features",
+            fg="red",
+        )