Huawei Cloud Ecs Alert

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Batch Query Monitoring Metrics
# Function: Batch query monitoring data for multiple ECS instances (CPU/memory/disk, etc.)
#
# Usage:
#   # Query CPU data for a single ECS
#   ./scripts/batch_query_metrics.sh --ecs-ids ecs-001 --metric cpu_util --period 1h
#
#   # Batch query multiple ECS instances
#   ./scripts/batch_query_metrics.sh --ecs-ids ecs-001,ecs-002,ecs-003 --metric cpu_util --period 24h --format table
#
#   # Export as JSON
#   ./scripts/batch_query_metrics.sh --ecs-ids ecs-001 --metric cpu_util --period 24h --format json > metrics.json
#

set -e

# Default values
ECS_IDS=""
METRIC=""
PERIOD="1h"
OUTPUT_FORMAT="table"
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --ecs-ids|-i)
            ECS_IDS="$2"
            shift 2
            ;;
        --metric|-m)
            METRIC="$2"
            shift 2
            ;;
        --period|-p)
            PERIOD="$2"
            shift 2
            ;;
        --format|-f)
            OUTPUT_FORMAT="$2"
            shift 2
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --ecs-ids, -i IDS     List of ECS instance IDs (comma-separated)"
            echo "  --metric, -m METRIC   Monitoring metric (cpu_util, memory_util, disk_util, etc.)"
            echo "  --period, -p PERIOD   Time range (1h, 24h, 7d, 30d)"
            echo "  --format, -f FORMAT   Output format: table (default), json, csv"
            echo "  --region, -r REGION   Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h            Show this help message"
            echo ""
            echo "Common metrics:"
            echo "  cpu_util      - CPU utilization (%)"
            echo "  memory_util   - Memory utilization (%) (requires Agent)"
            echo "  disk_util     - Disk utilization (%) (requires Agent)"
            echo "  net_bitRecv   - Network inbound traffic (Kbps)"
            echo "  net_bitSent   - Network outbound traffic (Kbps)"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Validate parameters
if [[ -z "$ECS_IDS" ]]; then
    echo "Error: --ecs-ids is required" >&2
    exit 1
fi

if [[ -z "$METRIC" ]]; then
    echo "Error: --metric is required" >&2
    exit 1
fi

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# Parse time range
parse_period() {
    local period="$1"
    local now
    now=$(date +%s)
    
    case $period in
        1h)
            echo $((now - 3600))
            ;;
        24h)
            echo $((now - 86400))
            ;;
        7d)
            echo $((now - 604800))
            ;;
        30d)
            echo $((now - 2592000))
            ;;
        *)
            # Default 1 hour
            echo $((now - 3600))
            ;;
    esac
}

# Query monitoring data
query_metric() {
    local ecs_id="$1"
    local metric="$2"
    local from_ts="$3"
    local to_ts="$4"
    local region="$5"
    
    # Convert to milliseconds
    local from_ms=$((from_ts * 1000))
    local to_ms=$((to_ts * 1000))
    
    hcloud CES ShowMetricData \
        --cli-region="$region" \
        --namespace=SYS.ECS \
        --metric_name="$metric" \
        --dim.0="instance_id,$ecs_id" \
        --period=300 \
        --filter=average \
        --from="$from_ms" \
        --to="$to_ms"
}

# Main logic
main() {
    echo "Batch querying monitoring data..." >&2
    echo "  Region: $REGION" >&2
    echo "  Metric: $METRIC" >&2
    echo "  Time range: $PERIOD" >&2
    echo "  ECS count: $(echo "$ECS_IDS" | tr ',' '\n' | wc -l)" >&2
    echo "" >&2
    
    # Calculate time range
    local to_ts
    to_ts=$(date +%s)
    local from_ts
    from_ts=$(parse_period "$PERIOD")
    
    # Store results
    declare -A results
    
    # Query monitoring data for each ECS
    IFS=',' read -ra IDS <<< "$ECS_IDS"
    for ecs_id in "${IDS[@]}"; do
        echo "Querying ECS: $ecs_id" >&2
        
        local metric_data
        metric_data=$(query_metric "$ecs_id" "$METRIC" "$from_ts" "$to_ts" "$REGION" 2>/dev/null || echo "{}")
        
        results["$ecs_id"]="$metric_data"
    done
    
    echo "" >&2
    
    # Process based on output format
    case $OUTPUT_FORMAT in
        json)
            echo "{"
            local first=true
            for ecs_id in "${!results[@]}"; do
                if [[ "$first" == true ]]; then
                    first=false
                else
                    echo ","
                fi
                echo "  \"$ecs_id\": ${results[$ecs_id]}"
            done
            echo "}"
            ;;
        csv)
            echo "ecs_id,timestamp,value"
            for ecs_id in "${!results[@]}"; do
                echo "${results[$ecs_id]}" | python3 -c "
import sys, json
data = json.load(sys.stdin)
datapoints = data.get('datapoints', [])
for dp in datapoints:
    ts = dp.get('timestamp', '')
    val = dp.get('average', '')
    print(f'$ecs_id,{ts},{val}')
"
            done
            ;;
        table|*)
            echo "================================================================================"
            echo "Monitoring Data Query Results"
            echo "================================================================================"
            echo ""
            
            for ecs_id in "${!results[@]}"; do
                echo "ECS: $ecs_id"
                echo "${results[$ecs_id]}" | python3 -c "
import sys, json
data = json.load(sys.stdin)
datapoints = data.get('datapoints', [])

if not datapoints:
    print('  No data available')
else:
    values = [dp.get('average', 0) for dp in datapoints]
    avg_val = sum(values) / len(values) if values else 0
    max_val = max(values) if values else 0
    min_val = min(values) if values else 0
    
    print(f'  Data points: {len(datapoints)}')
    print(f'  Average: {avg_val:.2f}')
    print(f'  Maximum: {max_val:.2f}')
    print(f'  Minimum: {min_val:.2f}')
"
                echo ""
            done
            ;;
    esac
    
    echo "Query complete" >&2
}

main

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Create CES Alarm Rules (using hcloud CLI)
# Function: Create alarm rules for ECS instances, supports preset templates or custom thresholds
#
# Usage:
#   # Use web template
#   ./scripts/create_alert_rules.sh --template web --ecs-ids ecs-001,ecs-002
#
#   # Custom threshold
#   ./scripts/create_alert_rules.sh --metric cpu_util --threshold 80 --ecs-ids ecs-001
#
#   # With notifications
#   ./scripts/create_alert_rules.sh --template web --ecs-ids ecs-001 --smn-topic-urn urn:smn:cn-north-4:xxx:ECS_ALARM_NOTIFY
#

set -e

# Default values
TEMPLATE=""
ECS_IDS=""
METRIC=""
THRESHOLD=""
OPERATOR=">"
LEVEL=2
SMN_TOPIC_URN=""
DRY_RUN=false
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --template|-t)
            TEMPLATE="$2"
            shift 2
            ;;
        --ecs-ids|-i)
            ECS_IDS="$2"
            shift 2
            ;;
        --metric|-m)
            METRIC="$2"
            shift 2
            ;;
        --threshold)
            THRESHOLD="$2"
            shift 2
            ;;
        --operator|-o)
            OPERATOR="$2"
            shift 2
            ;;
        --level|-l)
            LEVEL="$2"
            shift 2
            ;;
        --smn-topic-urn)
            SMN_TOPIC_URN="$2"
            shift 2
            ;;
        --dry-run)
            DRY_RUN=true
            shift
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --template, -t TEMPLATE    Preset template (web, database)"
            echo "  --ecs-ids, -i IDS          List of ECS instance IDs (comma-separated)"
            echo "  --metric, -m METRIC        Monitoring metric (cpu_util, memory_util, etc.)"
            echo "  --threshold VALUE          Alarm threshold"
            echo "  --operator, -o OPERATOR    Comparison operator (>, <, >=, <=)"
            echo "  --level, -l LEVEL          Alarm level (1=Info, 2=Important, 3=Minor, 4=General)"
            echo "  --smn-topic-urn URN        SMN topic URN (for alarm notifications)"
            echo "  --dry-run                  Preview configuration without creating"
            echo "  --region, -r REGION        Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h                 Show this help message"
            echo ""
            echo "Preset templates:"
            echo "  web       - Web server template (CPU > 70%, period 5min, count 3)"
            echo "  database  - Database template (CPU > 80%, period 5min, count 5)"
            echo ""
            echo "Examples:"
            echo "  # Create CPU alarm for multiple ECS using web template"
            echo "  $0 --template web --ecs-ids ecs-001,ecs-002"
            echo ""
            echo "  # Create custom memory alarm"
            echo "  $0 --metric memory_util --threshold 85 --ecs-ids ecs-001"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Validate parameters
if [[ -z "$ECS_IDS" ]]; then
    echo "Error: --ecs-ids is required" >&2
    exit 1
fi

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# Template configuration
declare -A TEMPLATES
TEMPLATES[web]="cpu_util,70,>,2,5,3"
TEMPLATES[database]="cpu_util,80,>,2,5,5"

# Parse template or use custom values
if [[ -n "$TEMPLATE" ]]; then
    if [[ -z "${TEMPLATES[$TEMPLATE]}" ]]; then
        echo "Error: Unknown template '$TEMPLATE'. Available: web, database" >&2
        exit 1
    fi
    
    IFS=',' read -r METRIC THRESHOLD OPERATOR LEVEL PERIOD COUNT <<< "${TEMPLATES[$TEMPLATE]}"
    echo "Using template: $TEMPLATE" >&2
    echo "  Metric: $METRIC" >&2
    echo "  Threshold: $THRESHOLD" >&2
    echo "  Operator: $OPERATOR" >&2
    echo "  Level: $LEVEL" >&2
    echo "  Period: $PERIOD min" >&2
    echo "  Count: $COUNT" >&2
else
    # Validate custom parameters
    if [[ -z "$METRIC" ]] || [[ -z "$THRESHOLD" ]]; then
        echo "Error: When not using --template, both --metric and --threshold are required" >&2
        exit 1
    fi
    PERIOD=5
    COUNT=3
fi

# Main logic
main() {
    echo "Creating alarm rules..." >&2
    echo "  Region: $REGION" >&2
    echo "  Metric: $METRIC" >&2
    echo "  Threshold: $THRESHOLD $OPERATOR" >&2
    echo "  ECS count: $(echo "$ECS_IDS" | tr ',' '\n' | wc -l)" >&2
    echo "" >&2
    
    if [[ "$DRY_RUN" == true ]]; then
        echo "[DRY RUN] Would create the following alarms:" >&2
        IFS=',' read -ra IDS <<< "$ECS_IDS"
        for ecs_id in "${IDS[@]}"; do
            echo "  - Alarm: ECS-${ecs_id:0:8}-${METRIC}" >&2
        done
        exit 0
    fi
    
    # Create alarm for each ECS
    IFS=',' read -ra IDS <<< "$ECS_IDS"
    for ecs_id in "${IDS[@]}"; do
        # Shorten ECS ID for alarm name (first 8 chars)
        local ecs_short="${ecs_id:0:8}"
        # Replace underscores with hyphens in metric name
        local metric_clean="${METRIC//_/-}"
        local alarm_name="ECS-${ecs_short}-${metric_clean}"
        
        echo "Creating alarm for ECS: $ecs_id" >&2
        echo "  Alarm name: $alarm_name" >&2
        
        # Build hcloud command
        local cmd="hcloud CES CreateAlarm \\
            --cli-region=\"$REGION\" \\
            --alarm_name=\"$alarm_name\" \\
            --alarm_type=\"MONITOR\" \\
            --alarm_level=$LEVEL \\
            --namespace=SYS.ECS \\
            --metric_name=\"$METRIC\" \\
            --dim.0=\"instance_id,$ecs_id\" \\
            --period=$PERIOD \\
            --filter=average \\
            --condition.0.metric_name=\"$METRIC\" \\
            --condition.0.operator=\"$OPERATOR\" \\
            --condition.0.threshold=$THRESHOLD \\
            --condition.0.count=$COUNT \\
            --condition.0.unit=\"\" \\
            --alarm_enabled=true"
        
        # Add SMN notification if provided
        if [[ -n "$SMN_TOPIC_URN" ]]; then
            cmd="$cmd \\
            --ok_actions.0=\"$SMN_TOPIC_URN\" \\
            --alarm_actions.0=\"$SMN_TOPIC_URN\""
        fi
        
        # Execute command
        if eval "$cmd"; then
            echo "  ✓ Alarm created successfully" >&2
        else
            echo "  ✗ Failed to create alarm" >&2
        fi
        
        echo "" >&2
    done
    
    echo "Alarm creation complete" >&2
}

main

#!/bin/bash
# SMN Email Subscription Creation Script
# Automatically uses hcloud CLI configured AK/SK, no need to set environment variables manually
#
# Usage:
#   ./scripts/create_email_subscription.sh

set -e

# Support environment variable configuration or use default placeholder values
TOPIC_URN="${SMN_TOPIC_URN:-urn:smn:cn-north-4:xxxxxxxxxxxxxxxxxxxxxxxxxxxxx:ECS_ALARM_NOTIFY}"
ENDPOINT="${ENDPOINT:-}"
REMARK="${REMARK:-ECS CPU Alarm Notification}"
REGION="${REGION:-cn-north-4}"

# If email is not provided, prompt for interactive input
if [ -z "$ENDPOINT" ]; then
    echo "=========================================="
    echo "SMN Email Subscription Creation"
    echo "=========================================="
    echo ""
    read -p "Please enter the email address to receive alarms: " ENDPOINT
    if [ -z "$ENDPOINT" ]; then
        echo "❌ Error: Email address cannot be empty"
        exit 1
    fi
    echo ""
fi

# Check if hcloud is available
if ! command -v hcloud &> /dev/null; then
    echo "❌ Error: hcloud command not found"
    echo "Please install Huawei Cloud CLI (KooCLI) >= 7.2.2 first"
    exit 1
fi

# Check hcloud configuration
echo "Checking hcloud configuration..."
if ! hcloud configure list &> /dev/null; then
    echo "❌ Error: hcloud credentials not configured"
    echo "Please run 'hcloud configure' to configure AK/SK first"
    exit 1
fi
echo "✅ hcloud configuration OK"
echo ""

# Create subscription
echo "Creating email subscription..."
RESULT=$(hcloud SMN AddSubscription \
    --cli-region="$REGION" \
    --topic_urn="$TOPIC_URN" \
    --protocol=email \
    --endpoint="$ENDPOINT" \
    --remark="$REMARK" 2>&1)

# Parse result
if echo "$RESULT" | grep -q "subscription_urn"; then
    SUBSCRIPTION_URN=$(echo "$RESULT" | grep -oP 'urn:smn:[^"]*')
    echo ""
    echo "✅ Subscription created successfully!"
    echo "   Subscription URN: $SUBSCRIPTION_URN"
    echo ""
    echo "⚠️  IMPORTANT: Please check email $ENDPOINT and click the confirmation link"
    echo "   Subscription will only be active after confirmation to receive alarm notifications"
    echo ""
    echo "=========================================="
    echo "Complete"
    echo "=========================================="
    exit 0
else
    echo "❌ Failed: $RESULT"
    exit 1
fi

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Query CES Alarm Rule List
# Function: Query and list all alarm rules, supports filtering by name/tag, outputs formatted list
#
# Usage:
#   # Query all alarms
#   ./scripts/list_alarms.sh
#
#   # Filter by name
#   ./scripts/list_alarms.sh --name ECS
#
#   # Output as JSON
#   ./scripts/list_alarms.sh --format json

set -e

# Default values
NAME_FILTER=""
OUTPUT_FORMAT="table"
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"
PAGE_SIZE=100

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --name|-n)
            NAME_FILTER="$2"
            shift 2
            ;;
        --format|-f)
            OUTPUT_FORMAT="$2"
            shift 2
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --name, -n NAME     Filter alarms by name (supports partial match)"
            echo "  --format, -f FORMAT Output format: table (default), json"
            echo "  --region, -r REGION Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h          Show this help message"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# Main logic
main() {
    echo "Querying alarm rules..." >&2
    echo "  Region: $REGION" >&2
    if [[ -n "$NAME_FILTER" ]]; then
        echo "  Filter: name contains '$NAME_FILTER'" >&2
    fi
    echo "" >&2
    
    # Build command
    local cmd="hcloud CES ListAlarms \
        --cli-region=\"$REGION\" \
        --limit=$PAGE_SIZE"
    
    if [[ -n "$NAME_FILTER" ]]; then
        cmd="$cmd --alarm_name=\"$NAME_FILTER\""
    fi
    
    # Execute and parse results
    local result
    result=$(eval "$cmd" 2>/dev/null)
    
    if [[ "$OUTPUT_FORMAT" == "json" ]]; then
        echo "$result"
    else
        # Parse and display as table
        echo "================================================================================"
        echo "CES Alarm Rule List"
        echo "================================================================================"
        echo ""
        
        # Use Python to parse JSON and format output
        echo "$result" | python3 -c "
import sys, json

try:
    data = json.load(sys.stdin)
    alarms = data.get('alarms', [])
    
    if not alarms:
        print('No alarm rules found')
        sys.exit(0)
    
    print(f'Found {len(alarms)} alarm rule(s)')
    print('')
    print(f'{\"ID\":<40} {\"Name\":<35} {\"Metric\":<20} {\"Level\":<6} {\"Status\":<10}')
    print('-' * 115)
    
    for alarm in alarms:
        alarm_id = alarm.get('alarm_id', 'N/A')[:36]
        name = alarm.get('alarm_name', 'N/A')[:30]
        metric = alarm.get('metric_name', 'N/A')
        level = alarm.get('alarm_level', 'N/A')
        status = alarm.get('alarm_enabled', False)
        status_str = 'Enabled' if status else 'Disabled'
        
        # Truncate long IDs with ellipsis
        if len(alarm_id) > 36:
            alarm_id = alarm_id[:33] + '...'
        
        print(f'{alarm_id:<40} {name:<35} {metric:<20} {level:<6} {status_str:<10}')
    
    print('')
    print('Query complete')
except Exception as e:
    print(f'Error parsing response: {e}', file=sys.stderr)
    print('Raw response:')
    print(data)
    sys.exit(1)
"
    fi
}

main

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Query ECS Instance List
# Function: Query and list all ECS instances, supports filtering by name, outputs formatted list
#
# Usage:
#   # Query all ECS instances
#   ./scripts/list_ecs.sh
#
#   # Filter by name
#   ./scripts/list_ecs.sh --name web
#
#   # Output as JSON
#   ./scripts/list_ecs.sh --format json

set -e

# Default values
NAME_FILTER=""
OUTPUT_FORMAT="table"
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --name|-n)
            NAME_FILTER="$2"
            shift 2
            ;;
        --format|-f)
            OUTPUT_FORMAT="$2"
            shift 2
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --name, -n NAME     Filter ECS by name (supports partial match)"
            echo "  --format, -f FORMAT Output format: table (default), json"
            echo "  --region, -r REGION Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h          Show this help message"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# Main logic
main() {
    echo "Querying ECS instances..." >&2
    echo "  Region: $REGION" >&2
    if [[ -n "$NAME_FILTER" ]]; then
        echo "  Filter: name contains '$NAME_FILTER'" >&2
    fi
    echo "" >&2
    
    # Build command
    local cmd="hcloud ECS ListServersDetails \
        --cli-region=\"$REGION\" \
        --limit=100"
    
    if [[ -n "$NAME_FILTER" ]]; then
        cmd="$cmd --name=\"$NAME_FILTER\""
    fi
    
    # Execute and parse results
    local result
    result=$(eval "$cmd" 2>/dev/null)
    
    if [[ "$OUTPUT_FORMAT" == "json" ]]; then
        echo "$result"
    else
        # Parse and display as table
        echo "================================================================================"
        echo "ECS Instance List"
        echo "================================================================================"
        echo ""
        
        # Use Python to parse JSON and format output
        echo "$result" | python3 -c "
import sys, json

try:
    data = json.load(sys.stdin)
    servers = data.get('servers', [])
    
    if not servers:
        print('No ECS instances found')
        sys.exit(0)
    
    print(f'Found {len(servers)} ECS instance(s)')
    print('')
    print(f'{\"ID\":<40} {\"Name\":<25} {\"Status\":<12} {\"Flavor\":<20} {\"IP Address\":<18}')
    print('-' * 115)
    
    for server in servers:
        server_id = server.get('id', 'N/A')[:36]
        name = server.get('name', 'N/A')[:22]
        status = server.get('status', 'N/A')
        flavor = server.get('flavor', {}).get('name', 'N/A')[:17]
        
        # Get first IP address
        addresses = server.get('addresses', {})
        ip = 'N/A'
        for network, addr_list in addresses.items():
            if addr_list:
                ip = addr_list[0].get('addr', 'N/A')[:15]
                break
        
        print(f'{server_id:<40} {name:<25} {status:<12} {flavor:<20} {ip:<18}')
    
    print('')
    print('Query complete')
except Exception as e:
    print(f'Error parsing response: {e}', file=sys.stderr)
    sys.exit(1)
"
    fi
}

main

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Query SMN Topics and Subscriptions List
# Usage:
#   # Query all topics
#   ./scripts/list_subscriptions.sh
#
#   # Query topic list only
#   ./scripts/list_subscriptions.sh --topics
#
#   # Query subscription list only
#   ./scripts/list_subscriptions.sh --subscriptions

set -e

# Default values
MODE="both"
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --topics|-t)
            MODE="topics"
            shift
            ;;
        --subscriptions|-s)
            MODE="subscriptions"
            shift
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --topics, -t          List SMN topics only"
            echo "  --subscriptions, -s   List SMN subscriptions only"
            echo "  --region, -r REGION   Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h            Show this help message"
            echo ""
            echo "Examples:"
            echo "  # List both topics and subscriptions"
            echo "  $0"
            echo ""
            echo "  # List topics only"
            echo "  $0 --topics"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# List topics
list_topics() {
    echo "Querying SMN topics..." >&2
    echo "  Region: $REGION" >&2
    echo "" >&2
    
    local result
    result=$(hcloud SMN ListTopics --cli-region="$REGION" 2>/dev/null)
    
    echo "================================================================================"
    echo "SMN Topic List"
    echo "================================================================================"
    echo ""
    
    echo "$result" | python3 -c "
import sys, json

try:
    data = json.load(sys.stdin)
    topics = data.get('topics', [])
    
    if not topics:
        print('No SMN topics found')
        sys.exit(0)
    
    print(f'Found {len(topics)} topic(s)')
    print('')
    print(f'{\"Topic Name\":<35} {\"Topic URN\":<80}')
    print('-' * 115)
    
    for topic in topics:
        name = topic.get('name', 'N/A')[:32]
        urn = topic.get('topic_urn', 'N/A')
        print(f'{name:<35} {urn:<80}')
    
    print('')
except Exception as e:
    print(f'Error parsing response: {e}', file=sys.stderr)
    sys.exit(1)
"
}

# List subscriptions
list_subscriptions() {
    echo "Querying SMN subscriptions..." >&2
    echo "  Region: $REGION" >&2
    echo "" >&2
    
    local result
    result=$(hcloud SMN ListSubscriptions --cli-region="$REGION" 2>/dev/null)
    
    echo "================================================================================"
    echo "SMN Subscription List"
    echo "================================================================================"
    echo ""
    
    echo "$result" | python3 -c "
import sys, json

try:
    data = json.load(sys.stdin)
    subscriptions = data.get('subscriptions', [])
    
    if not subscriptions:
        print('No SMN subscriptions found')
        sys.exit(0)
    
    print(f'Found {len(subscriptions)} subscription(s)')
    print('')
    print(f'{\"Protocol\":<12} {\"Endpoint\":<35} {\"Topic Name\":<30} {\"Status\":<10}')
    print('-' * 90)
    
    for sub in subscriptions:
        protocol = sub.get('protocol', 'N/A')
        endpoint = sub.get('endpoint', 'N/A')[:32]
        topic_name = sub.get('topic_name', 'N/A')[:27]
        status = sub.get('status', 0)
        status_str = 'Confirmed' if status == 1 else 'Pending'
        
        print(f'{protocol:<12} {endpoint:<35} {topic_name:<30} {status_str:<10}')
    
    print('')
    print('Note: Status 1 = Confirmed, 0 = Pending confirmation')
except Exception as e:
    print(f'Error parsing response: {e}', file=sys.stderr)
    sys.exit(1)
"
}

# Main logic
case $MODE in
    topics)
        list_topics
        ;;
    subscriptions)
        list_subscriptions
        ;;
    both)
        list_topics
        echo ""
        list_subscriptions
        ;;
esac

echo "Query complete" >&2

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Manage Alarm Notifications (SMN Topic Subscriptions)
# Function: Create/delete SMN subscriptions, configure alarm notification recipients
#
# Usage:
#   # Create email subscription (requires token confirmation, recommended via console)
#   ./scripts/manage_notifications.sh --action create --protocol email --endpoint user@example.com --topic-urn urn:smn:xxx
#
#   # Delete subscription
#   ./scripts/manage_notifications.sh --action delete --subscription-urn urn:smn:xxx:subscription

set -e

# Default values
ACTION=""
PROTOCOL=""
ENDPOINT=""
TOPIC_URN=""
SUBSCRIPTION_URN=""
REMARK="ECS Alarm Notification"
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --action|-a)
            ACTION="$2"
            shift 2
            ;;
        --protocol|-p)
            PROTOCOL="$2"
            shift 2
            ;;
        --endpoint|-e)
            ENDPOINT="$2"
            shift 2
            ;;
        --topic-urn)
            TOPIC_URN="$2"
            shift 2
            ;;
        --subscription-urn)
            SUBSCRIPTION_URN="$2"
            shift 2
            ;;
        --remark)
            REMARK="$2"
            shift 2
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --action, -a ACTION        Action: create, delete"
            echo "  --protocol, -p PROTOCOL    Protocol: email, sms (required for create)"
            echo "  --endpoint, -e ENDPOINT    Endpoint: email address or phone number (required for create)"
            echo "  --topic-urn URN            SMN topic URN (required for create)"
            echo "  --subscription-urn URN     SMN subscription URN (required for delete)"
            echo "  --remark TEXT              Subscription remark (optional)"
            echo "  --region, -r REGION        Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h                 Show this help message"
            echo ""
            echo "Examples:"
            echo "  # Create email subscription"
            echo "  $0 --action create --protocol email --endpoint user@example.com --topic-urn urn:smn:cn-north-4:xxx:ECS_ALARM"
            echo ""
            echo "  # Delete subscription"
            echo "  $0 --action delete --subscription-urn urn:smn:cn-north-4:xxx:subscription-id"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# Validate parameters
if [[ -z "$ACTION" ]]; then
    echo "Error: --action is required (create or delete)" >&2
    exit 1
fi

# Main logic
case $ACTION in
    create)
        if [[ -z "$PROTOCOL" ]] || [[ -z "$ENDPOINT" ]] || [[ -z "$TOPIC_URN" ]]; then
            echo "Error: For create action, --protocol, --endpoint, and --topic-urn are required" >&2
            exit 1
        fi
        
        echo "Creating SMN subscription..." >&2
        echo "  Region: $REGION" >&2
        echo "  Protocol: $PROTOCOL" >&2
        echo "  Endpoint: $ENDPOINT" >&2
        echo "  Topic URN: $TOPIC_URN" >&2
        echo "  Remark: $REMARK" >&2
        echo "" >&2
        
        RESULT=$(hcloud SMN AddSubscription \
            --cli-region="$REGION" \
            --topic_urn="$TOPIC_URN" \
            --protocol="$PROTOCOL" \
            --endpoint="$ENDPOINT" \
            --remark="$REMARK" 2>&1)
        
        if echo "$RESULT" | grep -q "subscription_urn"; then
            SUBSCRIPTION_URN=$(echo "$RESULT" | grep -oP 'urn:smn:[^"]*')
            echo "✅ Subscription created successfully!" >&2
            echo "   Subscription URN: $SUBSCRIPTION_URN" >&2
            echo "" >&2
            if [[ "$PROTOCOL" == "email" ]]; then
                echo "⚠️  IMPORTANT: Please check email $ENDPOINT and click the confirmation link" >&2
                echo "   Subscription will only be active after confirmation" >&2
            fi
        else
            echo "❌ Failed to create subscription: $RESULT" >&2
            exit 1
        fi
        ;;
    
    delete)
        if [[ -z "$SUBSCRIPTION_URN" ]]; then
            echo "Error: For delete action, --subscription-urn is required" >&2
            exit 1
        fi
        
        echo "Deleting SMN subscription..." >&2
        echo "  Subscription URN: $SUBSCRIPTION_URN" >&2
        echo "  Region: $REGION" >&2
        echo "" >&2
        
        if hcloud SMN DeleteSubscription \
            --cli-region="$REGION" \
            --subscription_urn="$SUBSCRIPTION_URN" 2>&1; then
            echo "✅ Subscription deleted successfully" >&2
        else
            echo "❌ Failed to delete subscription" >&2
            exit 1
        fi
        ;;
    
    *)
        echo "Error: Unknown action '$ACTION'. Valid actions: create, delete" >&2
        exit 1
        ;;
esac

echo "Operation complete" >&2

#!/usr/bin/env bash
# -*- coding: utf-8 -*-
#
# Update Alarm Rule Notification Configuration
# Function: Add/modify/remove SMN notifications for existing alarm rules
#
# Usage:
#   # Add notification to alarm
#   ./scripts/update_alarm_notifications.sh --action add --alarm-id xxx --smn-topic-urn urn:smn:xxx
#
#   # Remove notification from alarm
#   ./scripts/update_alarm_notifications.sh --action remove --alarm-id xxx

set -e

# Default values
ACTION=""
ALARM_ID=""
SMN_TOPIC_URN=""
REGION="${HUAWEI_CLOUD_REGION:-cn-north-4}"

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        --action|-a)
            ACTION="$2"
            shift 2
            ;;
        --alarm-id)
            ALARM_ID="$2"
            shift 2
            ;;
        --smn-topic-urn)
            SMN_TOPIC_URN="$2"
            shift 2
            ;;
        --region|-r)
            REGION="$2"
            shift 2
            ;;
        --help|-h)
            echo "Usage: $0 [options]"
            echo ""
            echo "Options:"
            echo "  --action, -a ACTION    Action: add, remove"
            echo "  --alarm-id ID          Alarm rule ID (required)"
            echo "  --smn-topic-urn URN    SMN topic URN (required for add action)"
            echo "  --region, -r REGION    Huawei Cloud region (default: cn-north-4)"
            echo "  --help, -h             Show this help message"
            echo ""
            echo "Examples:"
            echo "  # Add notification to alarm"
            echo "  $0 --action add --alarm-id alrm-xxx --smn-topic-urn urn:smn:cn-north-4:xxx:ECS_ALARM"
            echo ""
            echo "  # Remove notification from alarm"
            echo "  $0 --action remove --alarm-id alrm-xxx"
            exit 0
            ;;
        *)
            echo "Unknown option: $1" >&2
            echo "Use --help to see usage" >&2
            exit 1
            ;;
    esac
done

# Check if hcloud is installed
if ! command -v hcloud &> /dev/null; then
    echo "Error: hcloud command not found" >&2
    exit 1
fi

# Validate parameters
if [[ -z "$ALARM_ID" ]]; then
    echo "Error: --alarm-id is required" >&2
    exit 1
fi

if [[ -z "$ACTION" ]]; then
    echo "Error: --action is required (add or remove)" >&2
    exit 1
fi

# Main logic
case $ACTION in
    add)
        if [[ -z "$SMN_TOPIC_URN" ]]; then
            echo "Error: For add action, --smn-topic-urn is required" >&2
            exit 1
        fi
        
        echo "Adding notification to alarm..." >&2
        echo "  Alarm ID: $ALARM_ID" >&2
        echo "  SMN Topic URN: $SMN_TOPIC_URN" >&2
        echo "  Region: $REGION" >&2
        echo "" >&2
        
        # Update alarm with notification
        if hcloud CES UpdateAlarm \
            --cli-region="$REGION" \
            --alarm_id="$ALARM_ID" \
            --ok_actions.0="$SMN_TOPIC_URN" \
            --alarm_actions.0="$SMN_TOPIC_URN" 2>&1; then
            echo "✅ Notification added successfully" >&2
        else
            echo "❌ Failed to add notification" >&2
            exit 1
        fi
        ;;
    
    remove)
        echo "Removing notification from alarm..." >&2
        echo "  Alarm ID: $ALARM_ID" >&2
        echo "  Region: $REGION" >&2
        echo "" >&2
        
        # Update alarm without notifications (empty arrays)
        if hcloud CES UpdateAlarm \
            --cli-region="$REGION" \
            --alarm_id="$ALARM_ID" \
            --ok_actions="" \
            --alarm_actions="" 2>&1; then
            echo "✅ Notification removed successfully" >&2
        else
            echo "❌ Failed to remove notification" >&2
            exit 1
        fi
        ;;
    
    *)
        echo "Error: Unknown action '$ACTION'. Valid actions: add, remove" >&2
        exit 1
        ;;
esac

echo "Operation complete" >&2