skypilot-nightly 1.0.0.dev20250509__py3-none-any.whl → 1.0.0.dev20251107__py3-none-any.whl

sky/utils/kubernetes/ssh-tunnel.sh

@@ -0,0 +1,379 @@
+#!/bin/bash
+# ssh-tunnel.sh - SSH tunnel script for Kubernetes API access
+# Used as kubectl exec credential plugin to establish SSH tunnel on demand.
+# Returns a valid credential format for kubectl with expiration. The expiration
+# is calculated based on the TTL argument and is required to force kubectl to
+# check the tunnel status frequently.
+
+# Usage: ssh-tunnel.sh --host HOST [--user USER] [--use-ssh-config] [--ssh-key KEY] [--context CONTEXT] [--port PORT] [--ttl SECONDS]
+
+# Default time-to-live for credential in seconds
+# This forces kubectl to check the tunnel status frequently
+TTL_SECONDS=30
+
+# Parse arguments
+USE_SSH_CONFIG=0
+SSH_KEY=""
+CONTEXT=""
+HOST=""
+USER=""
+PORT=6443  # Default port if not specified
+
+# Debug log to ~/.sky/ssh_node_pools_info/$CONTEXT-tunnel.log
+debug_log() {
+    local message="$(date): $1"
+    echo "$message" >> "$LOG_FILE"
+}
+
+# Generate expiration timestamp for credential
+generate_expiration_timestamp() {
+  # Try macOS date format first, fallback to Linux format
+  date -u -v+${TTL_SECONDS}S +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date -u -d "+${TTL_SECONDS} seconds" +"%Y-%m-%dT%H:%M:%SZ"
+}
+
+# Acquire the lock, return 0 if successful, 1 if another process is already holding the lock
+acquire_lock() {
+  # Check for flock command
+  if ! command -v flock >/dev/null 2>&1; then
+    debug_log "flock command not available, using alternative lock mechanism"
+    # Simple file-based locking
+    if [ -f "$LOCK_FILE" ]; then
+      lock_pid=$(cat "$LOCK_FILE" 2>/dev/null)
+      if [ -n "$lock_pid" ] && kill -0 "$lock_pid" 2>/dev/null; then
+        debug_log "Another process ($lock_pid) is starting the tunnel, waiting briefly"
+        return 1
+      else
+        # Stale lock file
+        debug_log "Removing stale lock file"
+        rm -f "$LOCK_FILE"
+      fi
+    fi
+    # Create our lock
+    echo $$ > "$LOCK_FILE"
+    return 0
+  else
+    # Use flock for better locking
+    exec 9>"$LOCK_FILE"
+    if ! flock -n 9; then
+      debug_log "Another process is starting the tunnel, waiting briefly"
+      return 1
+    fi
+    return 0
+  fi
+}
+
+# Release the lock
+release_lock() {
+  if command -v flock >/dev/null 2>&1; then
+    # Using flock
+    exec 9>&- # Close file descriptor to release lock
+  else
+    # Using simple lock
+    rm -f "$LOCK_FILE"
+  fi
+  debug_log "Lock released"
+}
+
+# Generate SSH command based on available tools and parameters
+generate_ssh_command() {
+  # Check for autossh
+  if ! command -v autossh >/dev/null 2>&1; then
+    debug_log "WARNING: autossh is not installed but recommended for reliable SSH tunnels"
+    debug_log "Install autossh: brew install autossh (macOS), apt-get install autossh (Ubuntu/Debian)"
+    
+    # Fall back to regular ssh
+    if [[ $USE_SSH_CONFIG -eq 1 ]]; then
+      SSH_CMD=("ssh" "-o" "ServerAliveInterval=30" "-o" "ServerAliveCountMax=3" "-o" "ExitOnForwardFailure=yes" "-L" "$PORT:127.0.0.1:6443" "-N" "$HOST")
+    else
+      SSH_CMD=("ssh" "-o" "StrictHostKeyChecking=no" "-o" "IdentitiesOnly=yes" "-o" "ServerAliveInterval=30" "-o" "ServerAliveCountMax=3" "-o" "ExitOnForwardFailure=yes" "-L" "$PORT:127.0.0.1:6443" "-N")
+      
+      # Add SSH key if provided
+      if [[ -n "$SSH_KEY" ]]; then
+        SSH_CMD+=("-i" "$SSH_KEY")
+      fi
+      
+      # Add user@host
+      SSH_CMD+=("$USER@$HOST")
+    fi
+  else
+    # Configure autossh
+    if [[ $USE_SSH_CONFIG -eq 1 ]]; then
+      SSH_CMD=("autossh" "-M" "0" "-o" "ServerAliveInterval=30" "-o" "ServerAliveCountMax=3" "-o" "ExitOnForwardFailure=yes" "-L" "$PORT:127.0.0.1:6443" "-N" "$HOST")
+    else
+      SSH_CMD=("autossh" "-M" "0" "-o" "StrictHostKeyChecking=no" "-o" "IdentitiesOnly=yes" "-o" "ServerAliveInterval=30" "-o" "ServerAliveCountMax=3" "-o" "ExitOnForwardFailure=yes" "-L" "$PORT:127.0.0.1:6443" "-N")
+      
+      # Add SSH key if provided
+      if [[ -n "$SSH_KEY" ]]; then
+        SSH_CMD+=("-i" "$SSH_KEY")
+      fi
+      
+      # Add user@host
+      SSH_CMD+=("$USER@$HOST")
+    fi
+  fi
+}
+
+# Function to read certificate files if they exist
+read_certificate_data() {
+  local client_cert_file="$TUNNEL_DIR/$CONTEXT-cert.pem"
+  local client_key_file="$TUNNEL_DIR/$CONTEXT-key.pem"
+  local cert_data=""
+  local key_data=""
+  
+  if [[ -f "$client_cert_file" ]]; then
+    # Read the certificate file as is - it's already in PEM format
+    cert_data=$(cat "$client_cert_file")
+    debug_log "Found client certificate data for context $CONTEXT"
+    
+    # Log the first and last few characters to verify PEM format
+    local cert_start=$(head -1 "$client_cert_file")
+    local cert_end=$(tail -1 "$client_cert_file")
+    debug_log "Certificate starts with: $cert_start"
+    debug_log "Certificate ends with: $cert_end"
+    
+    # Check if it has proper PEM format
+    if ! grep -q "BEGIN CERTIFICATE" "$client_cert_file" || ! grep -q "END CERTIFICATE" "$client_cert_file"; then
+      debug_log "WARNING: Certificate file may not be in proper PEM format"
+      # Try to fix it if needed
+      if ! grep -q "BEGIN CERTIFICATE" "$client_cert_file"; then
+        echo "-----BEGIN CERTIFICATE-----" > "$client_cert_file.fixed"
+        cat "$client_cert_file" >> "$client_cert_file.fixed"
+        echo "-----END CERTIFICATE-----" >> "$client_cert_file.fixed"
+        mv "$client_cert_file.fixed" "$client_cert_file"
+        cert_data=$(cat "$client_cert_file")
+        debug_log "Fixed certificate format by adding BEGIN/END markers"
+      fi
+    fi
+  fi
+  
+  if [[ -f "$client_key_file" ]]; then
+    # Read the key file as is - it's already in PEM format
+    key_data=$(cat "$client_key_file")
+    debug_log "Found client key data for context $CONTEXT"
+    
+    # Log the first and last few characters to verify PEM format
+    local key_start=$(head -1 "$client_key_file")
+    local key_end=$(tail -1 "$client_key_file")
+    debug_log "Key starts with: $key_start"
+    debug_log "Key ends with: $key_end"
+    
+    # Check if it has proper PEM format
+    if ! grep -q "BEGIN" "$client_key_file" || ! grep -q "END" "$client_key_file"; then
+      debug_log "WARNING: Key file may not be in proper PEM format"
+      # Try to fix it if needed
+      if ! grep -q "BEGIN" "$client_key_file"; then
+        echo "-----BEGIN PRIVATE KEY-----" > "$client_key_file.fixed"
+        cat "$client_key_file" >> "$client_key_file.fixed"
+        echo "-----END PRIVATE KEY-----" >> "$client_key_file.fixed"
+        mv "$client_key_file.fixed" "$client_key_file"
+        key_data=$(cat "$client_key_file")
+        debug_log "Fixed key format by adding BEGIN/END markers"
+      fi
+    fi
+  fi
+  
+  echo "$cert_data:$key_data"
+}
+
+# Function to generate credentials JSON
+generate_credentials_json() {
+  local expiration_time=$(generate_expiration_timestamp)
+  local cert_bundle=$(read_certificate_data)
+  local client_cert_data=${cert_bundle%:*}
+  local client_key_data=${cert_bundle#*:}
+  
+  if [[ -n "$client_cert_data" && -n "$client_key_data" ]]; then
+    # Debug the certificate data
+    debug_log "Certificate data length: $(echo -n "$client_cert_data" | wc -c) bytes"
+    debug_log "Key data length: $(echo -n "$client_key_data" | wc -c) bytes"
+    
+    # Check if we can create proper JSON with `jq`
+    if ! command -v jq &>/dev/null; then
+      echo "jq is not installed. Please install jq to use this script." >&2
+      exit 1
+    fi
+    debug_log "Using jq for JSON formatting"
+    
+    # Create a temporary file for the JSON output to avoid shell escaping issues
+    local TEMP_JSON_FILE=$(mktemp)
+    
+    # Write the JSON to the temporary file using jq for proper JSON formatting
+    cat > "$TEMP_JSON_FILE" << EOL
+{
+  "apiVersion": "client.authentication.k8s.io/v1beta1",
+  "kind": "ExecCredential",
+  "status": {
+    "clientCertificateData": $(printf '%s' "$client_cert_data" | jq -R -s .),
+    "clientKeyData": $(printf '%s' "$client_key_data" | jq -R -s .),
+    "expirationTimestamp": "$expiration_time"
+  }
+}
+EOL
+      
+    # Read the JSON from the file
+    local json_response=$(cat "$TEMP_JSON_FILE")
+    
+    # Clean up
+    rm -f "$TEMP_JSON_FILE"
+    
+    # Output the JSON
+    echo "$json_response"
+  else
+    # Fallback to token-based credential for tunnel-only authentication
+    echo "{\"apiVersion\":\"client.authentication.k8s.io/v1beta1\",\"kind\":\"ExecCredential\",\"status\":{\"token\":\"k8s-ssh-tunnel-token\",\"expirationTimestamp\":\"$expiration_time\"}}"
+  fi
+}
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --use-ssh-config)
+      USE_SSH_CONFIG=1
+      shift
+      ;;
+    --ssh-key)
+      SSH_KEY="$2"
+      shift 2
+      ;;
+    --context)
+      CONTEXT="$2"
+      shift 2
+      ;;
+    --port)
+      PORT="$2"
+      shift 2
+      ;;
+    --host)
+      HOST="$2"
+      shift 2
+      ;;
+    --user)
+      USER="$2"
+      shift 2
+      ;;
+    --ttl)
+      TTL_SECONDS="$2"
+      shift 2
+      ;;
+    *)
+      echo "Unknown parameter: $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+# Validate required parameters
+if [[ -z "$HOST" ]]; then
+  echo "Error: --host parameter is required" >&2
+  exit 1
+fi
+
+# Setup directories
+TUNNEL_DIR="$HOME/.sky/ssh_node_pools_info"
+mkdir -p "$TUNNEL_DIR"
+
+# Get context name for PID file
+if [[ -z "$CONTEXT" ]]; then
+  CONTEXT="default"
+fi
+
+PID_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.pid"
+LOG_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.log"
+LOCK_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.lock"
+
+debug_log "Starting ssh-tunnel.sh for context $CONTEXT, host $HOST, port $PORT"
+debug_log "SSH Config: $USE_SSH_CONFIG, User: $USER, TTL: ${TTL_SECONDS}s"
+
+# Check if specified port is already in use (tunnel may be running)
+if nc -z 127.0.0.1 "$PORT" 2>/dev/null; then
+  debug_log "Port $PORT already in use, checking if it's our tunnel"
+  
+  # Check if there's a PID file and if that process is running
+  if [[ -f "$PID_FILE" ]]; then
+    OLD_PID=$(cat "$PID_FILE")
+    if kill -0 "$OLD_PID" 2>/dev/null; then
+      debug_log "Tunnel appears to be running with PID $OLD_PID"
+    else
+      debug_log "PID file exists but process $OLD_PID is not running"
+    fi
+  else
+    debug_log "Port $PORT is in use but no PID file exists"
+  fi
+  
+  # Return valid credential format for kubectl with expiration
+  generate_credentials_json
+  exit 0
+fi
+
+# Try to acquire the lock
+if ! acquire_lock; then
+  # Wait briefly for the tunnel to be established
+  for i in {1..10}; do
+    if nc -z 127.0.0.1 "$PORT" 2>/dev/null; then
+      debug_log "Tunnel is now active"
+      
+      # Return valid credential format for kubectl with expiration
+      generate_credentials_json
+      exit 0
+    fi
+    sleep 0.2
+  done
+  debug_log "Waited for tunnel but port $PORT still not available"
+fi
+
+# Check if we have a PID file with running process
+if [[ -f "$PID_FILE" ]]; then
+  OLD_PID=$(cat "$PID_FILE")
+  if kill -0 "$OLD_PID" 2>/dev/null; then
+    # Process exists but port isn't open - something's wrong, kill it
+    kill "$OLD_PID" 2>/dev/null
+    debug_log "Killed stale tunnel process $OLD_PID"
+  else
+    debug_log "PID file exists but process $OLD_PID is not running anymore"
+  fi
+  # Remove the stale PID file
+  rm -f "$PID_FILE"
+fi
+
+# Generate the SSH command
+generate_ssh_command
+
+debug_log "Starting SSH tunnel: ${SSH_CMD[*]}"
+
+# Start the tunnel in foreground and wait for it to establish
+"${SSH_CMD[@]}" >> "$LOG_FILE" 2>&1 &
+TUNNEL_PID=$!
+
+# Save PID
+echo $TUNNEL_PID > "$PID_FILE"
+debug_log "Tunnel started with PID $TUNNEL_PID"
+
+# Wait for tunnel to establish
+tunnel_up=0
+for i in {1..20}; do
+  if nc -z 127.0.0.1 "$PORT" 2>/dev/null; then
+    debug_log "Tunnel established successfully on port $PORT"
+    tunnel_up=1
+    break
+  fi
+  sleep 0.2
+done
+
+# Clean up lock file
+release_lock
+
+# Check if the tunnel process is still running
+if ! kill -0 $TUNNEL_PID 2>/dev/null; then
+  debug_log "ERROR: Tunnel process exited unexpectedly! Check logs for details"
+  if [[ -f "$PID_FILE" ]]; then
+    rm -f "$PID_FILE"
+  fi
+  # Return error in case of tunnel failure
+  echo "Failed to establish SSH tunnel. See $TUNNEL_DIR/$CONTEXT-tunnel.log for details." >&2
+  exit 1
+elif [[ $tunnel_up -eq 0 ]]; then
+  debug_log "WARNING: Tunnel process is running but port $PORT is not responding"
+fi
+
+# Return valid credential format with certificates if available
+generate_credentials_json
+exit 0 

sky/utils/kubernetes/ssh_utils.py

@@ -0,0 +1,221 @@
+"""Utility functions for managing SSH node pools."""
+import os
+import re
+import subprocess
+from typing import Any, Callable, Dict, List, Optional
+import uuid
+
+import yaml
+
+from sky.utils import ux_utils
+
+DEFAULT_SSH_NODE_POOLS_PATH = os.path.expanduser('~/.sky/ssh_node_pools.yaml')
+RED = '\033[0;31m'
+NC = '\033[0m'  # No color
+
+
+def check_host_in_ssh_config(hostname: str) -> bool:
+    """Return True iff *hostname* matches at least one `Host`/`Match` stanza
+    in the user's OpenSSH client configuration (including anything pulled in
+    via Include).
+
+    It calls:  ssh -vvG <hostname> -o ConnectTimeout=0
+    which:
+      • -G  expands the effective config without connecting
+      • -vv prints debug lines that show which stanzas are applied
+      • ConnectTimeout=0 avoids a DNS lookup if <hostname> is a FQDN/IP
+
+    No config files are opened or parsed manually.
+
+    Parameters
+    ----------
+    hostname : str
+        The alias/IP/FQDN you want to test.
+
+    Returns
+    -------
+    bool
+        True  – a specific stanza matched the host
+        False – nothing but the global defaults (`Host *`) applied
+    """
+    # We direct stderr→stdout because debug output goes to stderr.
+    proc = subprocess.run(
+        ['ssh', '-vvG', hostname, '-o', 'ConnectTimeout=0'],
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=False,  # we only want the text, not to raise
+    )
+
+    # Look for lines like:
+    #   debug1: ~/.ssh/config line 42: Applying options for <hostname>
+    # Anything other than "*"
+    pattern = re.compile(r'^debug\d+: .*Applying options for ([^*].*)$',
+                         re.MULTILINE)
+
+    return bool(pattern.search(proc.stdout))
+
+
+class UniqueKeySafeLoader(yaml.SafeLoader):
+    """Custom YAML loader that raises an error if there are duplicate keys."""
+
+    def construct_mapping(self, node, deep=False):
+        mapping = set()
+        for key_node, _ in node.value:
+            key = self.construct_object(key_node, deep=deep)
+            if key in mapping:
+                raise yaml.constructor.ConstructorError(
+                    note=(f'Duplicate key found: {key!r}.\n'
+                          'Please remove one of them from the YAML file.'))
+            mapping.add(key)
+        return super().construct_mapping(node, deep)
+
+
+def load_ssh_targets(file_path: str) -> Dict[str, Any]:
+    """Load SSH targets from YAML file."""
+    if not os.path.exists(file_path):
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'SSH Node Pools file not found: {file_path}')
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            targets = yaml.load(f, Loader=UniqueKeySafeLoader)
+        return targets
+    except yaml.constructor.ConstructorError as e:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(e.note) from e
+    except (yaml.YAMLError, IOError, OSError) as e:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'Error loading SSH Node Pools file: {e}') from e
+
+
+def get_cluster_config(
+        targets: Dict[str, Any],
+        cluster_name: Optional[str] = None,
+        file_path: str = DEFAULT_SSH_NODE_POOLS_PATH) -> Dict[str, Any]:
+    """Get configuration for specific clusters or all clusters."""
+    if not targets:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'No clusters defined in SSH Node Pools file {file_path}')
+
+    if cluster_name:
+        if cluster_name not in targets:
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'Cluster {cluster_name!r} not found in '
+                                 f'SSH Node Pools file {file_path}')
+        return {cluster_name: targets[cluster_name]}
+
+    # Return all clusters if no specific cluster is specified
+    return targets
+
+
+def prepare_hosts_info(
+    cluster_name: str,
+    cluster_config: Dict[str, Any],
+    upload_ssh_key_func: Optional[Callable[[str, str], str]] = None
+) -> List[Dict[str, str]]:
+    """Prepare list of hosts with resolved user, identity_file, and password.
+
+    Args:
+        cluster_name: The name of the cluster.
+        cluster_config: The configuration for the cluster.
+        upload_ssh_key_func: A function to upload the SSH key to the remote
+            server and wait for the key to be uploaded. This function will take
+            the key name and the local key file path as input, and return the
+            path for the remote SSH key file on the API server. This function
+            will only be set in `sky ssh up -f` mode, and if this function is
+            set, any ssh config will not be allowed as we don't support
+            uploading any ssh config to the API server.
+
+    Returns:
+        A list of hosts with resolved user, identity_file, and password.
+    """
+    if 'hosts' not in cluster_config or not cluster_config['hosts']:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'No hosts defined in cluster {cluster_name} configuration')
+
+    # Get cluster-level defaults
+    cluster_user = cluster_config.get('user', '')
+    cluster_identity_file = os.path.expanduser(
+        cluster_config.get('identity_file', ''))
+    cluster_password = cluster_config.get('password', '')
+
+    # Check if cluster identity file exists
+    if cluster_identity_file and not os.path.isfile(cluster_identity_file):
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'SSH Identity File Missing: {cluster_identity_file}')
+
+    use_cluster_config_msg = (f'Cluster {cluster_name} uses SSH config '
+                              'for hostname {host}, which is not '
+                              'supported by the -f flag. Please use a '
+                              'dict with `ip` field instead.')
+
+    def _maybe_hardcode_identity_file(i: int, identity_file: str) -> str:
+        if upload_ssh_key_func is None:
+            return identity_file
+        if not os.path.exists(os.path.expanduser(identity_file)):
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    f'Identity file {identity_file} does not exist.')
+        key_name = f'{cluster_name}-{i}-{str(uuid.uuid4())[:4]}'
+        key_file_on_api_server = upload_ssh_key_func(key_name, identity_file)
+        return key_file_on_api_server
+
+    hosts_info = []
+    for i, host in enumerate(cluster_config['hosts']):
+        # Host can be a string (IP or SSH config hostname) or a dict
+        if isinstance(host, str):
+            # Check if this is an SSH config hostname
+            is_ssh_config_host = check_host_in_ssh_config(host)
+            if upload_ssh_key_func is not None and is_ssh_config_host:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(use_cluster_config_msg.format(host=host))
+
+            hosts_info.append({
+                'ip': host,
+                'user': '' if is_ssh_config_host else cluster_user,
+                'identity_file': '' if is_ssh_config_host else
+                                 _maybe_hardcode_identity_file(
+                                     i, cluster_identity_file),
+                'password': cluster_password,
+                'use_ssh_config': is_ssh_config_host
+            })
+        else:
+            # It's a dict with potential overrides
+            if 'ip' not in host:
+                print(f'{RED}Warning: Host missing \'ip\' field, '
+                      f'skipping: {host}{NC}')
+                continue
+
+            # Check if this is an SSH config hostname
+            is_ssh_config_host = check_host_in_ssh_config(host['ip'])
+            if upload_ssh_key_func is not None and is_ssh_config_host:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(use_cluster_config_msg.format(host=host))
+
+            # Use host-specific values or fall back to cluster defaults
+            host_user = '' if is_ssh_config_host else host.get(
+                'user', cluster_user)
+            host_identity_file = '' if is_ssh_config_host else (
+                _maybe_hardcode_identity_file(
+                    i, host.get('identity_file', cluster_identity_file)))
+            host_identity_file = os.path.expanduser(host_identity_file)
+            host_password = host.get('password', cluster_password)
+
+            if host_identity_file and not os.path.isfile(host_identity_file):
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        f'SSH Identity File Missing: {host_identity_file}')
+
+            hosts_info.append({
+                'ip': host['ip'],
+                'user': host_user,
+                'identity_file': host_identity_file,
+                'password': host_password,
+                'use_ssh_config': is_ssh_config_host
+            })
+
+    return hosts_info

sky/utils/kubernetes_enums.py

@@ -2,26 +2,13 @@
 import enum
 
 
+# TODO(kevin): Remove this enum in v0.13.0.
 class KubernetesNetworkingMode(enum.Enum):
-    """Enum for the different types of networking modes for accessing
-    jump pods.
+    """Enum for the different types of networking modes for accessing pods.
     """
     NODEPORT = 'nodeport'
     PORTFORWARD = 'portforward'
 
-    @classmethod
-    def from_str(cls, mode: str) -> 'KubernetesNetworkingMode':
-        """Returns the enum value for the given string."""
-        if mode.lower() == cls.NODEPORT.value:
-            return cls.NODEPORT
-        elif mode.lower() == cls.PORTFORWARD.value:
-            return cls.PORTFORWARD
-        else:
-            raise ValueError(f'Unsupported kubernetes networking mode: '
-                             f'{mode}. The mode must be either '
-                             f'\'{cls.PORTFORWARD.value}\' or '
-                             f'\'{cls.NODEPORT.value}\'. ')
-
 
 class KubernetesServiceType(enum.Enum):
     """Enum for the different types of services."""
@@ -42,4 +29,10 @@ class KubernetesAutoscalerType(enum.Enum):
     """Enum for the different types of cluster autoscalers for Kubernetes."""
     GKE = 'gke'
     KARPENTER = 'karpenter'
+    COREWEAVE = 'coreweave'
     GENERIC = 'generic'
+
+    def emits_autoscale_event(self) -> bool:
+        """Returns whether specific autoscaler emits the event reason
+        TriggeredScaleUp."""
+        return self not in {self.KARPENTER}