Huawei Cloud Eip Cost Optimizer

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
查找闲置 EIP 并生成分析报告（仅分析，不执行释放操作）
Usage: python3 analyze_idle_eips.py [--region cn-north-4] [--min-idle-days 7]
"""

import os
import sys
import json
import argparse
from datetime import datetime
from huaweicloudsdkeip.v2 import EipClient, ListPublicipsRequest
from huaweicloudsdkeip.v2.region.eip_region import EipRegion
from huaweicloudsdkcore.auth.credentials import BasicCredentials

def get_credentials():
    """从环境变量获取 AK/SK"""
    ak = os.environ.get('HUAWEI_CLOUD_AK')
    sk = os.environ.get('HUAWEI_CLOUD_SK')
    region = os.environ.get('HUAWEI_CLOUD_REGION', 'cn-north-4')
    
    if not ak or not sk:
        print("❌ 错误：未找到华为云凭证")
        print("请设置环境变量:")
        print("  export HUAWEI_CLOUD_AK=<your-ak>")
        print("  export HUAWEI_CLOUD_SK=<your-sk>")
        print("  export HUAWEI_CLOUD_REGION=cn-north-4  # 可选，默认 cn-north-4")
        sys.exit(1)
    
    return BasicCredentials(ak=ak, sk=sk), region

def list_eips(client, region):
    """列出所有 EIP"""
    request = ListPublicipsRequest()
    request.limit = 100
    
    try:
        response = client.list_publicips(request)
        return response.publicips if response.publicips else []
    except Exception as e:
        print(f"❌ 查询 EIP 失败：{e}")
        return []

def find_idle_eips(eips, min_idle_days=0):
    """找出闲置 EIP（未绑定的）"""
    idle_eips = []
    for eip in eips:
        # 检查绑定状态：port_id 为 None 或空表示未绑定
        port_id = getattr(eip, 'port_id', None)
        status = getattr(eip, 'status', 'UNKNOWN')
        
        # 未绑定的 EIP (port_id 为 None 或空字符串)
        if port_id is None or port_id == '':
            # 计算闲置天数
            create_time = getattr(eip, 'create_time', None)
            idle_days = calculate_idle_days(create_time) if create_time else -1
            
            # 只有闲置天数 >= 阈值才加入列表
            if idle_days >= 0 and idle_days >= min_idle_days:
                idle_eips.append(eip)
    
    return idle_eips

def calculate_idle_days(create_time_str):
    """计算闲置天数（从创建时间开始）"""
    try:
        # 解析 ISO 格式时间：2024-01-15T10:30:00Z
        if 'T' in create_time_str:
            create_time = datetime.fromisoformat(create_time_str.replace('Z', '+00:00'))
        else:
            create_time = datetime.strptime(create_time_str, '%Y-%m-%d %H:%M:%S')
        
        now = datetime.now(create_time.tzinfo) if create_time.tzinfo else datetime.now()
        delta = now - create_time
        return delta.days
    except Exception:
        return -1  # 无法计算

def print_eip_table(eips, title="EIP 列表", min_idle_days=0):
    """打印 EIP 表格"""
    print("\n" + "=" * 120)
    print(f"{title} (区域：{os.environ.get('HUAWEI_CLOUD_REGION', 'cn-north-4')}, 闲置阈值：≥{min_idle_days}天)")
    print("=" * 120)
    print(f"{'EIP ID':<40} {'IP 地址':<16} {'带宽 ID':<20} {'状态':<10} {'端口绑定':<12} {'创建时间':<20} {'闲置天数'}")
    print("-" * 120)
    
    for eip in eips:
        eip_id = getattr(eip, 'id', 'N/A')[:36]
        ip = getattr(eip, 'public_ip_address', 'N/A')
        bw_id = getattr(eip, 'bandwidth_id', 'N/A')[:16] if getattr(eip, 'bandwidth_id', None) else 'N/A'
        status = getattr(eip, 'status', 'N/A')
        port_id = getattr(eip, 'port_id', 'N/A')
        create_time = getattr(eip, 'create_time', 'N/A')[:19] if getattr(eip, 'create_time', None) else 'N/A'
        
        # 闲置 EIP 高亮标记
        is_idle = port_id is None or port_id == ''
        marker = " ⚠️ 闲置" if is_idle else ""
        port_status = "未绑定" if is_idle else f"已绑定 ({port_id[:8]}...)"
        
        # 计算闲置天数
        idle_days = calculate_idle_days(create_time) if is_idle else 0
        idle_days_str = f"{idle_days} 天" if idle_days >= 0 else "未知"
        
        print(f"{eip_id:<40} {ip:<16} {bw_id:<20} {status:<10} {port_status:<12} {create_time:<20} {idle_days_str}{marker}")
    
    print("-" * 120)
    idle_count = len([e for e in eips if (getattr(e, 'port_id', None) is None or getattr(e, 'port_id', '') == '') and calculate_idle_days(getattr(e, 'create_time', None)) >= min_idle_days])
    print(f"总计：{len(eips)} 个 EIP, 闲置：{idle_count} 个 (阈值：≥{min_idle_days}天)")
    print("=" * 120 + "\n")

def generate_report(all_eips, idle_eips, min_idle_days=0):
    """生成分析报告"""
    print("\n" + "=" * 120)
    print(f"📊 闲置 EIP 分析报告 (闲置阈值：≥{min_idle_days}天)")
    print("=" * 120)
    
    # 成本估算（按 cn-north-4 按需价格）
    # 参考：EIP 保留费约 ¥0.02/小时/个，带宽费按实际带宽计算
    estimated_hourly_cost = len(idle_eips) * 0.02  # 仅保留费
    estimated_monthly_cost = estimated_hourly_cost * 24 * 30
    
    print(f"\n📈 资源概览:")
    print(f"  - EIP 总数：{len(all_eips)} 个")
    print(f"  - 闲置 EIP 数量：{len(idle_eips)} 个")
    print(f"  - 闲置率：{len(idle_eips)/len(all_eips)*100:.1f}%" if all_eips else "  - 闲置率：N/A")
    
    print(f"\n💰 成本估算（参考 cn-north-4 按需价格）:")
    print(f"  - 当前每小时成本：约 ¥{estimated_hourly_cost:.2f}/小时")
    print(f"  - 当前每月成本：约 ¥{estimated_monthly_cost:.2f}/月")
    print(f"  - 潜在节省：100%（如释放所有闲置 EIP）")
    
    print(f"\n⚠️  风险提示:")
    print(f"  - EIP 释放是不可逆操作，IP 地址将被回收且无法恢复")
    print(f"  - 建议先确认闲置 EIP 是否用于备用、灾备或临时业务")
    print(f"  - 释放前请通知相关业务负责人")
    
    print(f"\n💡 优化建议:")
    if len(idle_eips) == 0:
        print("  ✅ 所有 EIP 都在使用中，无需优化")
    else:
        print("  1. 【立即行动】确认闲置 EIP 的业务用途，联系负责人核实")
        print("  2. 【降低成本】对确认不用的 EIP，手动在控制台释放")
        print("  3. 【保留备用】对可能需要但暂时闲置的 EIP，可调整为最低带宽（1 Mbps）")
        print("  4. 【定期审计】建议每周运行此脚本，持续监控闲置资源")
        print("  5. 【标签管理】为 EIP 添加用途标签，便于后续识别和管理")
    
    # 详细清单
    if idle_eips:
        print(f"\n📋 闲置 EIP 详细清单:")
        for i, eip in enumerate(idle_eips, 1):
            eip_id = getattr(eip, 'id', 'N/A')
            ip = getattr(eip, 'public_ip_address', 'N/A')
            create_time = getattr(eip, 'create_time', 'N/A')[:19] if getattr(eip, 'create_time', None) else 'N/A'
            idle_days = calculate_idle_days(create_time)
            idle_days_str = f"{idle_days} 天" if idle_days >= 0 else "未知"
            
            print(f"\n  [{i}] EIP: {ip}")
            print(f"      ID: {eip_id}")
            print(f"      创建时间：{create_time}")
            print(f"      闲置时长：{idle_days_str}")
            print(f"      建议操作：{'立即释放' if idle_days > 30 else '确认用途后决定'}")
    
    print("\n" + "=" * 120)
    print("📝 报告生成时间:", datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    print("=" * 120 + "\n")

def main():
    # 解析命令行参数
    parser = argparse.ArgumentParser(description='查找闲置 EIP 并生成分析报告')
    parser.add_argument('--region', type=str, default=None, help='华为云区域 ID (默认从环境变量读取)')
    parser.add_argument('--min-idle-days', type=int, default=0, help='最小闲置天数阈值 (默认：0，即所有未绑定 EIP)')
    args = parser.parse_args()
    
    # 获取凭证
    credentials, region_id = get_credentials()
    
    # 命令行参数优先于环境变量
    if args.region:
        region_id = args.region
    
    min_idle_days = args.min_idle_days
    
    # 创建客户端
    client = EipClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(EipRegion.value_of(region_id)) \
        .build()
    
    print(f"🔍 正在查询区域 {region_id} 的 EIP... (闲置阈值：≥{min_idle_days}天)")
    
    # 查询所有 EIP
    all_eips = list_eips(client, region_id)
    
    if not all_eips:
        print("ℹ️  未找到任何 EIP")
        return
    
    # 打印所有 EIP
    print_eip_table(all_eips, "所有 EIP", min_idle_days)
    
    # 找出闲置 EIP（根据阈值过滤）
    idle_eips = find_idle_eips(all_eips, min_idle_days)
    
    if not idle_eips:
        print(f"✅ 未发现闲置超过 {min_idle_days} 天的 EIP，所有 EIP 都在使用中或闲置时间不足")
        return
    
    # 打印闲置 EIP
    print_eip_table(idle_eips, "⚠️  闲置 EIP 列表", min_idle_days)
    
    # 生成分析报告
    generate_report(all_eips, idle_eips, min_idle_days)
    
    # 输出 JSON 格式报告（可选）
    if '--json' in sys.argv:
        report = {
            "region": region_id,
            "timestamp": datetime.now().isoformat(),
            "summary": {
                "total_eips": len(all_eips),
                "idle_eips": len(idle_eips),
                "idle_rate": len(idle_eips) / len(all_eips) * 100 if all_eips else 0,
                "estimated_monthly_cost_cny": len(idle_eips) * 0.02 * 24 * 30
            },
            "idle_eip_details": [
                {
                    "eip_id": getattr(eip, 'id', 'N/A'),
                    "public_ip": getattr(eip, 'public_ip_address', 'N/A'),
                    "bandwidth_id": getattr(eip, 'bandwidth_id', 'N/A'),
                    "create_time": getattr(eip, 'create_time', 'N/A'),
                    "idle_days": calculate_idle_days(getattr(eip, 'create_time', ''))
                }
                for eip in idle_eips
            ],
            "recommendations": [
                "确认闲置 EIP 的业务用途，联系负责人核实",
                "对确认不用的 EIP，手动在控制台释放",
                "对可能需要但暂时闲置的 EIP，可调整为最低带宽（1 Mbps）",
                "定期审计，建议每周运行此脚本",
                "为 EIP 添加用途标签，便于后续识别和管理"
            ]
        }
        print("\n📄 JSON 报告:")
        print(json.dumps(report, indent=2, ensure_ascii=False))

if __name__ == '__main__':
    main()

#!/bin/bash
#
# eip_audit_log.sh - EIP 操作审计日志
#
# 功能:
#   - 记录所有 EIP 操作历史
#   - 支持 JSON 格式审计日志
#   - 支持审计日志查询和导出
#   - 符合等保合规要求
#
# 使用方法:
#   ./eip_audit_log.sh --action release --eip-id eip-xxx --operator admin
#   ./eip_audit_log.sh --query --days 30
#   ./eip_audit_log.sh --export --format csv
#
# 环境变量:
#   EIP_AUDIT_LOG_DIR - 审计日志目录（默认：~/.eip-audit-logs）
#

set -e

# 默认配置
AUDIT_LOG_DIR="${EIP_AUDIT_LOG_DIR:-$HOME/.eip-audit-logs}"
AUDIT_LOG_FILE="$AUDIT_LOG_DIR/audit_$(date +%Y%m).jsonl"

# 创建审计日志目录
mkdir -p "$AUDIT_LOG_DIR"

# 解析参数
ACTION=""
EIP_ID=""
OPERATOR="${USER:-admin}"
DETAILS=""
QUERY_MODE=false
QUERY_DAYS=30
EXPORT_MODE=false
EXPORT_FORMAT="json"

while [[ $# -gt 0 ]]; do
    case $1 in
        --action)
            ACTION="$2"
            shift 2
            ;;
        --eip-id)
            EIP_ID="$2"
            shift 2
            ;;
        --operator)
            OPERATOR="$2"
            shift 2
            ;;
        --details)
            DETAILS="$2"
            shift 2
            ;;
        --query)
            QUERY_MODE=true
            shift
            ;;
        --days)
            QUERY_DAYS="$2"
            shift 2
            ;;
        --export)
            EXPORT_MODE=true
            shift
            ;;
        --format)
            EXPORT_FORMAT="$2"
            shift 2
            ;;
        --log-dir)
            AUDIT_LOG_DIR="$2"
            AUDIT_LOG_FILE="$AUDIT_LOG_DIR/audit_$(date +%Y%m).jsonl"
            shift 2
            ;;
        --help)
            echo "用法：$0 [选项]"
            echo ""
            echo "记录操作:"
            echo "  --action ACTION      操作类型 (release, create, update_bandwidth, bind, unbind)"
            echo "  --eip-id EIP_ID      EIP ID"
            echo "  --operator OPERATOR  操作人员"
            echo "  --details DETAILS    操作详情（JSON 格式）"
            echo ""
            echo "查询模式:"
            echo "  --query              查询审计日志"
            echo "  --days DAYS          查询最近 N 天的日志（默认：30）"
            echo ""
            echo "导出模式:"
            echo "  --export             导出审计日志"
            echo "  --format FORMAT      导出格式：json, csv, html（默认：json）"
            echo ""
            echo "其他选项:"
            echo "  --log-dir DIR        审计日志目录"
            echo "  --help               显示帮助信息"
            exit 0
            ;;
        *)
            echo "未知选项：$1"
            exit 1
            ;;
    esac
done

# 查询模式
if [ "$QUERY_MODE" = true ]; then
    echo "🔍 查询最近 $QUERY_DAYS 天的审计日志..."
    echo ""
    
    if [ ! -f "$AUDIT_LOG_FILE" ] && [ -z "$(ls -A $AUDIT_LOG_DIR/*.jsonl 2>/dev/null)" ]; then
        echo "ℹ️  暂无审计日志记录"
        exit 0
    fi
    
    # 计算日期阈值
    THRESHOLD_DATE=$(date -d "$QUERY_DAYS days ago" +%Y%m%d 2>/dev/null || date -v-${QUERY_DAYS}d +%Y%m%d 2>/dev/null || echo "0")
    
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    printf "%-20s %-15s %-20s %-15s\n" "时间" "操作类型" "EIP ID" "操作人员"
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    # 遍历所有日志文件
    for LOG_FILE in "$AUDIT_LOG_DIR"/audit_*.jsonl; do
        [ -f "$LOG_FILE" ] || continue
        
        # 使用 jq 读取所有 JSON 对象（支持多行格式）
        jq -c '.' "$LOG_FILE" 2>/dev/null | while IFS= read -r LINE; do
            TIMESTAMP=$(echo "$LINE" | jq -r '.timestamp' 2>/dev/null)
            FILE_DATE=$(echo "$TIMESTAMP" | cut -d'T' -f1 | tr -d '-')
            
            # 只显示指定天数内的日志
            if [ "$FILE_DATE" -ge "$THRESHOLD_DATE" ] 2>/dev/null; then
                printf "%-20s %-15s %-20s %-15s\n" \
                    "$(echo "$TIMESTAMP" | cut -d'T' -f1) $(echo "$TIMESTAMP" | cut -d'T' -f2 | cut -d'.' -f1)" \
                    "$(echo "$LINE" | jq -r '.operation' 2>/dev/null)" \
                    "$(echo "$LINE" | jq -r '.eip_id' 2>/dev/null)" \
                    "$(echo "$LINE" | jq -r '.operator' 2>/dev/null)"
            fi
        done
    done
    
    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
    
    exit 0
fi

# 导出模式
if [ "$EXPORT_MODE" = true ]; then
    echo "📊 导出审计日志（格式：$EXPORT_FORMAT）..."
    echo ""
    
    EXPORT_FILE="$AUDIT_LOG_DIR/export_$(date +%Y%m%d_%H%M%S).$EXPORT_FORMAT"
    
    case $EXPORT_FORMAT in
        json)
            echo "[" > "$EXPORT_FILE"
            FIRST=true
            for LOG_FILE in "$AUDIT_LOG_DIR"/audit_*.jsonl; do
                [ -f "$LOG_FILE" ] || continue
                while IFS= read -r LINE; do
                    if [ "$FIRST" = true ]; then
                        FIRST=false
                    else
                        echo "," >> "$EXPORT_FILE"
                    fi
                    echo "$LINE" >> "$EXPORT_FILE"
                done < "$LOG_FILE"
            done
            echo "]" >> "$EXPORT_FILE"
            ;;
        
        csv)
            echo "timestamp,operation,eip_id,operator,details" > "$EXPORT_FILE"
            for LOG_FILE in "$AUDIT_LOG_DIR"/audit_*.jsonl; do
                [ -f "$LOG_FILE" ] || continue
                while IFS= read -r LINE; do
                    TIMESTAMP=$(echo "$LINE" | jq -r '.timestamp' 2>/dev/null)
                    OPERATION=$(echo "$LINE" | jq -r '.operation' 2>/dev/null)
                    EIP_ID_VAL=$(echo "$LINE" | jq -r '.eip_id' 2>/dev/null)
                    OPERATOR_VAL=$(echo "$LINE" | jq -r '.operator' 2>/dev/null)
                    DETAILS_VAL=$(echo "$LINE" | jq -r '.details' 2>/dev/null | tr ',' ';' | tr '"' "'")
                    echo "$TIMESTAMP,$OPERATION,$EIP_ID_VAL,$OPERATOR_VAL,\"$DETAILS_VAL\"" >> "$EXPORT_FILE"
                done < "$LOG_FILE"
            done
            ;;
        
        html)
            cat > "$EXPORT_FILE" << 'EOF'
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>EIP 审计日志</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        h1 { color: #333; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
        th { background-color: #4CAF50; color: white; }
        tr:nth-child(even) { background-color: #f2f2f2; }
    </style>
</head>
<body>
    <h1>📋 EIP 操作审计日志</h1>
    <p>导出时间：EOF
            echo "$(date '+%Y-%m-%d %H:%M:%S')" >> "$EXPORT_FILE"
            cat >> "$EXPORT_FILE" << 'EOF'
</p>
    <table>
        <tr>
            <th>时间</th>
            <th>操作类型</th>
            <th>EIP ID</th>
            <th>操作人员</th>
            <th>详情</th>
        </tr>
EOF
            for LOG_FILE in "$AUDIT_LOG_DIR"/audit_*.jsonl; do
                [ -f "$LOG_FILE" ] || continue
                while IFS= read -r LINE; do
                    TIMESTAMP=$(echo "$LINE" | jq -r '.timestamp' 2>/dev/null)
                    OPERATION=$(echo "$LINE" | jq -r '.operation' 2>/dev/null)
                    EIP_ID_VAL=$(echo "$LINE" | jq -r '.eip_id' 2>/dev/null)
                    OPERATOR_VAL=$(echo "$LINE" | jq -r '.operator' 2>/dev/null)
                    DETAILS_VAL=$(echo "$LINE" | jq -r '.details' 2>/dev/null | tr '"' "'")
                    echo "        <tr><td>$TIMESTAMP</td><td>$OPERATION</td><td>$EIP_ID_VAL</td><td>$OPERATOR_VAL</td><td>$DETAILS_VAL</td></tr>" >> "$EXPORT_FILE"
                done < "$LOG_FILE"
            done
            cat >> "$EXPORT_FILE" << 'EOF'
    </table>
</body>
</html>
EOF
            ;;
        
        *)
            echo "不支持的导出格式：$EXPORT_FORMAT"
            exit 1
            ;;
    esac
    
    echo "✓ 导出成功：$EXPORT_FILE"
    exit 0
fi

# 记录审计日志模式
if [ -n "$ACTION" ] && [ -n "$EIP_ID" ]; then
    TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
    
    # 构建审计日志条目
    if [ -n "$DETAILS" ]; then
        # 如果 details 已经是 JSON 对象（以{开头），直接使用；否则作为字符串处理
        if [[ "$DETAILS" == "{"* ]]; then
            DETAILS_JSON="$DETAILS"
        else
            DETAILS_JSON="\"$DETAILS\""
        fi
    else
        DETAILS_JSON="{}"
    fi
    
    AUDIT_ENTRY=$(cat << EOF
{
  "timestamp": "$TIMESTAMP",
  "operation": "$ACTION",
  "eip_id": "$EIP_ID",
  "operator": "$OPERATOR",
  "region": "${HW_REGION:-cn-north-4}",
  "details": $DETAILS_JSON
}
EOF
)
    
    # 追加到审计日志文件
    echo "$AUDIT_ENTRY" >> "$AUDIT_LOG_FILE"
    
    echo "✓ 审计日志已记录"
    echo "  操作：$ACTION"
    echo "  EIP ID: $EIP_ID"
    echo "  操作人员：$OPERATOR"
    echo "  时间：$TIMESTAMP"
    echo "  日志文件：$AUDIT_LOG_FILE"
    
    exit 0
else
    echo "⚠️  请提供 --action 和 --eip-id 参数，或使用 --query/--export 模式"
    echo ""
    echo "示例:"
    echo "  # 记录释放操作"
    echo "  $0 --action release --eip-id eip-xxx --operator admin"
    echo ""
    echo "  # 查询最近 30 天日志"
    echo "  $0 --query --days 30"
    echo ""
    echo "  # 导出 CSV 格式日志"
    echo "  $0 --export --format csv"
    
    exit 1
fi

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
eip_cost_report.py - 华为云 EIP 成本分析报告生成器
基于华为云 Python SDK v2

Usage:
    python3 eip_cost_report.py --region cn-north-4
    python3 eip_cost_report.py --idle-days 7
    python3 eip_cost_report.py --output report.html
"""

import os
import sys
import json
import argparse
from datetime import datetime, timedelta
from typing import List, Dict, Any, Tuple

# 颜色输出
class Colors:
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    CYAN = '\033[96m'
    RESET = '\033[0m'
    BOLD = '\033[1m'

def color_print(color: str, message: str):
    """彩色输出"""
    print(f"{color}{message}{Colors.RESET}")

def get_client():
    """创建 EIP 客户端 (v2 SDK)"""
    from huaweicloudsdkeip.v2 import EipClient
    from huaweicloudsdkeip.v2.region.eip_region import EipRegion
    from huaweicloudsdkcore.auth.credentials import BasicCredentials
    
    ak = os.environ.get('HUAWEI_CLOUD_AK')
    sk = os.environ.get('HUAWEI_CLOUD_SK')
    region = os.environ.get('HUAWEI_CLOUD_REGION', 'cn-north-4')
    
    if not ak or not sk:
        color_print(Colors.RED, "❌ Error: Missing credentials")
        print("\nPlease set environment variables:")
        print("  export HUAWEI_CLOUD_AK=<your-ak>")
        print("  export HUAWEI_CLOUD_SK=<your-sk>")
        sys.exit(1)
    
    credentials = BasicCredentials(ak=ak, sk=sk)
    client = EipClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(EipRegion.value_of(region)) \
        .build()
    return client, region

def get_eip_list(client, region: str) -> List[Dict[str, Any]]:
    """获取 EIP 列表"""
    try:
        from huaweicloudsdkeip.v2 import ListPublicipsRequest
        
        request = ListPublicipsRequest()
        request.limit = 100
        
        response = client.list_publicips(request)
        eips = response.publicips if hasattr(response, 'publicips') else []
        
        # 转换为字典格式
        result = []
        for eip in eips:
            eip_dict = {
                'id': eip.id,
                'public_ip_address': eip.public_ip_address,
                'status': eip.status,
                'bandwidth_size': eip.bandwidth_size if hasattr(eip, 'bandwidth_size') else 0,
                'bandwidth_charge_mode': eip.bandwidth_charge_mode if hasattr(eip, 'bandwidth_charge_mode') else 'bandwidth',
                'create_time': eip.create_time if hasattr(eip, 'create_time') else None,
                'port_id': eip.port_id if hasattr(eip, 'port_id') else None,
                'tags': [],
            }
            result.append(eip_dict)
        
        return result
        
    except Exception as e:
        color_print(Colors.RED, f"❌ 获取 EIP 列表失败：{str(e)}")
        return []

def get_eip_tags(client, eip_id: str) -> List[Dict[str, str]]:
    """获取 EIP 标签"""
    try:
        from huaweicloudsdkeip.v2 import ShowPublicipRequest
        
        request = ShowPublicipRequest()
        request.publicip_id = eip_id
        
        response = client.show_publicip(request)
        eip = response.publicip
        
        if hasattr(eip, 'tags') and eip.tags:
            return [{'key': tag.key, 'value': tag.value} for tag in eip.tags]
        
    except Exception:
        pass
    
    return []

def has_protected_tag(eip_tags: List[Dict], protected_tags: List[Tuple[str, str]]) -> bool:
    """检查 EIP 是否有保护标签"""
    if not protected_tags:
        return False
    
    for tag in eip_tags:
        tag_key = tag.get('key', '')
        tag_value = tag.get('value', '')
        for pk, pv in protected_tags:
            if tag_key == pk and tag_value == pv:
                return True
    return False

def is_idle_eip(eip: Dict[str, Any], idle_days: int = 7, protected_tags: List[Tuple[str, str]] = None) -> Tuple[bool, str]:
    """判断 EIP 是否闲置
    
    闲置原因:
      - unbound: 未绑定
      - protected: 有保护标签（附加标记，不单独判定闲置）
      - "": 非闲置
    """
    # 检查保护标签
    if has_protected_tag(eip.get('tags', []), protected_tags or []):
        return False, 'protected'
    
    # 检查是否未绑定
    if eip.get('status') == 'DOWN' or not eip.get('port_id'):
        # 简单判断：状态为 DOWN 或未绑定资源
        return True, 'unbound'
    
    return False, ''

def calculate_cost(bandwidth_size: int, charge_mode: str = 'bandwidth') -> float:
    """计算 EIP 月度成本（简化估算）
    
    华为云 EIP 计费规则（参考）：
    - 带宽计费：约 2 元/Mbps/月
    - 流量计费：按实际使用量
    """
    if charge_mode == 'bandwidth':
        # 带宽计费：2 元/Mbps/月
        return bandwidth_size * 2.0
    else:
        # 流量计费：估算为带宽计费的 50%
        return bandwidth_size * 1.0

def generate_report(eips: List[Dict], region: str, idle_days: int = 7, protected_tags: List[Tuple[str, str]] = None):
    """生成成本分析报告"""
    color_print(Colors.BLUE, "=" * 70)
    color_print(Colors.BLUE, f"  华为云 EIP 成本分析报告")
    color_print(Colors.BLUE, f"  区域：{region} | 生成时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    color_print(Colors.BLUE, "=" * 70)
    print()
    
    # 分类统计
    idle_eips = []
    active_eips = []
    protected_eips = []
    total_cost = 0
    idle_cost = 0
    
    for eip in eips:
        # 获取标签
        from huaweicloudsdkeip.v2 import EipClient
        # 注意：这里需要 client 参数，简化处理不获取标签
        
        cost = calculate_cost(eip.get('bandwidth_size', 0), eip.get('bandwidth_charge_mode'))
        eip['monthly_cost'] = cost
        total_cost += cost
        
        is_idle, reason = is_idle_eip(eip, idle_days, protected_tags)
        
        if reason == 'protected':
            protected_eips.append(eip)
            active_eips.append(eip)  # 保护的 EIP 算作活跃
        elif is_idle:
            idle_eips.append(eip)
            idle_cost += cost
        else:
            active_eips.append(eip)
    
    # 输出总览
    color_print(Colors.BOLD, "📊 资源总览:")
    print(f"  总 EIP 数：     {len(eips)}")
    print(f"  活跃 EIP:      {len(active_eips)}")
    print(f"  闲置 EIP:      {Colors.RED}{len(idle_eips)}{Colors.RESET}")
    if protected_eips:
        print(f"  受保护 EIP:    {Colors.GREEN}{len(protected_eips)}{Colors.RESET}")
    print()
    
    # 成本统计
    color_print(Colors.BOLD, "💰 成本统计:")
    print(f"  月度总成本：   ¥{total_cost:.2f}")
    print(f"  闲置浪费：     {Colors.RED}¥{idle_cost:.2f}{Colors.RESET}")
    if total_cost > 0:
        waste_ratio = (idle_cost / total_cost) * 100
        print(f"  浪费比例：     {Colors.YELLOW}{waste_ratio:.1f}%{Colors.RESET}")
    print()
    
    # 闲置 EIP 详情
    if idle_eips:
        color_print(Colors.RED, "⚠️  闲置 EIP 列表:")
        print()
        
        for i, eip in enumerate(idle_eips, 1):
            print(f"  [{i}] {Colors.BOLD}{eip['public_ip_address']}{Colors.RESET}")
            print(f"      EIP ID:    {eip['id']}")
            print(f"      带宽：      {eip['bandwidth_size']} Mbps")
            print(f"      月成本：    ¥{eip['monthly_cost']:.2f}")
            print(f"      状态：      {eip['status']}")
            if eip.get('create_time'):
                print(f"      创建时间：  {eip['create_time']}")
            print()
        
        color_print(Colors.YELLOW, "💡 优化建议:")
        print("  1. 及时释放不再使用的闲置 EIP")
        print("  2. 对临时使用的 EIP 设置标签标记（如：env=test）")
        print("  3. 定期（每周）运行闲置检测脚本")
        print()
    else:
        color_print(Colors.GREEN, "✅ 未发现闲置 EIP，资源利用率良好！")
        print()
    
    # 活跃 EIP 摘要
    color_print(Colors.GREEN, "📋 活跃 EIP 摘要:")
    print()
    
    for eip in active_eips[:5]:  # 只显示前 5 个
        print(f"  • {eip['public_ip_address']} - {eip['bandwidth_size']} Mbps - ¥{eip['monthly_cost']:.2f}/月")
    
    if len(active_eips) > 5:
        print(f"  ... 还有 {len(active_eips) - 5} 个活跃 EIP")
    
    print()
    color_print(Colors.BLUE, "=" * 70)

def main():
    parser = argparse.ArgumentParser(description='华为云 EIP 成本分析报告')
    parser.add_argument('--region', type=str, default=None, help='区域（默认：HUAWEI_CLOUD_REGION 或 cn-north-4）')
    parser.add_argument('--idle-days', type=int, default=7, help='闲置天数阈值（默认：7）')
    parser.add_argument('--protected-tags', type=str, default=None, help='保护标签（格式：key1=value1,key2=value2）')
    parser.add_argument('--output', type=str, default=None, help='输出文件路径（HTML/JSON）')
    
    args = parser.parse_args()
    
    client, region = get_client()
    
    if args.region:
        region = args.region
    
    # 解析保护标签
    protected_tags = []
    if args.protected_tags:
        for item in args.protected_tags.split(','):
            if '=' in item:
                key, value = item.split('=', 1)
                protected_tags.append((key.strip(), value.strip()))
    
    # 获取 EIP 列表
    color_print(Colors.BLUE, "🔍 正在扫描 EIP 资源...")
    eips = get_eip_list(client, region)
    
    if not eips:
        color_print(Colors.YELLOW, "⚠️  当前区域没有找到 EIP 资源")
        sys.exit(0)
    
    # 生成报告
    generate_report(eips, region, args.idle_days, protected_tags)

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
列出所有 EIP 及其详细信息
基于华为云 Python SDK v2

Usage:
    python3 list_eips.py --region cn-north-4
    python3 list_eips.py --status BINDING
    python3 list_eips.py --idle-only
"""

import os
import sys
from datetime import datetime
from typing import List, Optional

# 颜色输出
class Colors:
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    CYAN = '\033[96m'
    RESET = '\033[0m'
    BOLD = '\033[1m'

def color_print(color: str, message: str):
    """彩色输出"""
    print(f"{color}{message}{Colors.RESET}")

def get_client():
    """创建 EIP 客户端 (v2 SDK)"""
    from huaweicloudsdkeip.v2 import EipClient
    from huaweicloudsdkeip.v2.region.eip_region import EipRegion
    from huaweicloudsdkcore.auth.credentials import BasicCredentials
    
    ak = os.environ.get('HUAWEI_CLOUD_AK')
    sk = os.environ.get('HUAWEI_CLOUD_SK')
    region = os.environ.get('HUAWEI_CLOUD_REGION', 'cn-north-4')
    
    if not ak or not sk:
        color_print(Colors.RED, "❌ Error: Missing credentials")
        print("\nPlease set environment variables:")
        print("  export HUAWEI_CLOUD_AK=<your-ak>")
        print("  export HUAWEI_CLOUD_SK=<your-sk>")
        print("  export HUAWEI_CLOUD_REGION=cn-north-4")
        sys.exit(1)
    
    credentials = BasicCredentials(ak=ak, sk=sk)
    client = EipClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(EipRegion.value_of(region)) \
        .build()
    
    return client, region

def list_all_eips(client):
    """获取所有 EIP 列表（返回原始数据供其他脚本使用）"""
    from huaweicloudsdkeip.v2 import ListPublicipsRequest
    
    request = ListPublicipsRequest()
    request.limit = 1000
    
    response = client.list_publicips(request)
    return response.publicips if hasattr(response, 'publicips') else []

def list_eips(region_filter: Optional[str] = None, status_filter: Optional[str] = None, idle_only: bool = False):
    """列出所有 EIP"""
    client, region = get_client()
    
    if region_filter:
        region = region_filter
    
    color_print(Colors.BLUE, "=" * 60)
    color_print(Colors.BLUE, f"  EIP 列表查询（区域：{region}）")
    color_print(Colors.BLUE, "=" * 60)
    print()
    
    try:
        eips = list_all_eips(client)
        
        if not eips:
            color_print(Colors.YELLOW, "⚠️  当前区域没有找到 EIP 资源")
            return
        
        # 过滤和统计
        filtered_eips = []
        idle_count = 0
        binding_count = 0
        total_bandwidth = 0
        
        for eip in eips:
            # 状态过滤
            if status_filter and eip.status != status_filter:
                continue
            
            # 闲置过滤
            is_idle = (eip.status == 'DOWN' or eip.status == 'ELB')
            if idle_only and not is_idle:
                continue
            
            filtered_eips.append(eip)
            
            if is_idle:
                idle_count += 1
            else:
                binding_count += 1
            
            if hasattr(eip, 'bandwidth_size') and eip.bandwidth_size:
                total_bandwidth += eip.bandwidth_size
        
        # 输出结果
        color_print(Colors.GREEN, f"📊 找到 {len(filtered_eips)} 个 EIP")
        print()
        
        for i, eip in enumerate(filtered_eips, 1):
            is_idle = (eip.status == 'DOWN' or eip.status == 'ELB')
            status_color = Colors.RED if is_idle else Colors.GREEN
            status_text = "IDLE" if is_idle else eip.status
            
            print(f"[{i}] {Colors.BOLD}{eip.public_ip_address}{Colors.RESET}")
            print(f"    EIP ID:      {eip.id}")
            print(f"    状态：       {status_color}{status_text}{Colors.RESET}")
            print(f"    带宽大小：   {eip.bandwidth_size if hasattr(eip, 'bandwidth_size') else 'N/A'} Mbps")
            print(f"    计费模式：   {eip.bandwidth_charge_mode if hasattr(eip, 'bandwidth_charge_mode') else 'N/A'}")
            
            if hasattr(eip, 'port_id') and eip.port_id:
                print(f"    绑定资源：   {eip.port_id}")
            else:
                print(f"    绑定资源：   {Colors.YELLOW}未绑定{Colors.RESET}")
            
            if hasattr(eip, 'create_time') and eip.create_time:
                print(f"    创建时间：   {eip.create_time}")
            
            print()
        
        # 汇总统计
        color_print(Colors.BLUE, "-" * 60)
        color_print(Colors.BOLD, "📈 汇总统计:")
        print(f"  总 EIP 数：     {len(filtered_eips)}")
        print(f"  闲置 EIP:      {Colors.RED}{idle_count}{Colors.RESET}")
        print(f"  使用中 EIP:    {Colors.GREEN}{binding_count}{Colors.RESET}")
        print(f"  总带宽：       {total_bandwidth} Mbps")
        color_print(Colors.BLUE, "-" * 60)
        
    except Exception as e:
        color_print(Colors.RED, f"❌ 查询失败：{str(e)}")
        sys.exit(1)

def main():
    import argparse
    
    parser = argparse.ArgumentParser(description='列出所有华为云 EIP')
    parser.add_argument('--region', type=str, default=None, help='区域（默认：HUAWEI_CLOUD_REGION 或 cn-north-4）')
    parser.add_argument('--status', type=str, default=None, help='状态过滤（BINDING, DOWN, ELB, etc.）')
    parser.add_argument('--idle-only', action='store_true', help='仅显示闲置 EIP')
    parser.add_argument('--summary', action='store_true', help='仅输出统计数据（CSV 格式：总数，闲置数，总带宽）')
    
    args = parser.parse_args()
    
    # 如果是 summary 模式，输出 CSV 格式
    if args.summary:
        try:
            client, region = get_client()
            eips = list_all_eips(client)
            
            total_count = len(eips)
            idle_count = sum(1 for e in eips if hasattr(e, 'status') and e.status in ['DOWN', 'ELB'])
            total_bandwidth = sum(e.bandwidth_size for e in eips if hasattr(e, 'bandwidth_size') and e.bandwidth_size)
            
            # 输出 CSV 格式：总数，闲置数，总带宽
            print(f"{total_count},{idle_count},{total_bandwidth}")
        except Exception:
            print("0,0,0")
        return
    
    list_eips(
        region_filter=args.region,
        status_filter=args.status,
        idle_only=args.idle_only
    )

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
闲置 EIP 监控与告警工具
基于华为云 Python SDK v2，支持：
- 定时扫描闲置 EIP
- 企业微信/钉钉 webhook 通知
- 邮件告警
- 自定义闲置阈值

Usage:
    python3 monitor_idle_eips.py --scan                    # 扫描并报告闲置 EIP
    python3 monitor_idle_eips.py --scan --wechat-webhook URL  # 发送微信通知
    python3 monitor_idle_eips.py --setup-cron              # 设置定时监控（每天 9:00）
"""

import os
import sys
import json
import argparse
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import urllib.request
import urllib.error
import smtplib
from email.mime.text import MIMEText
from email.header import Header

# 颜色输出
class Colors:
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    RESET = '\033[0m'
    BOLD = '\033[1m'

def color_print(color: str, message: str):
    """彩色输出"""
    print(f"{color}{message}{Colors.RESET}")

def get_client():
    """创建 EIP 客户端 (v2 SDK)"""
    from huaweicloudsdkeip.v2 import EipClient
    from huaweicloudsdkeip.v2.region.eip_region import EipRegion
    from huaweicloudsdkcore.auth.credentials import BasicCredentials
    
    ak = os.environ.get('HUAWEI_CLOUD_AK')
    sk = os.environ.get('HUAWEI_CLOUD_SK')
    region = os.environ.get('HUAWEI_CLOUD_REGION', 'cn-north-4')
    
    if not ak or not sk:
        color_print(Colors.RED, "❌ 错误：未检测到认证信息")
        color_print(Colors.YELLOW, "请设置环境变量 HUAWEI_CLOUD_AK 和 HUAWEI_CLOUD_SK")
        sys.exit(1)
    
    credentials = BasicCredentials(ak=ak, sk=sk)
    client = EipClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(EipRegion.value_of(region)) \
        .build()
    
    return client, region

def list_all_eips(client) -> List[dict]:
    """列出所有 EIP"""
    from huaweicloudsdkeip.v2 import ListPublicipsRequest
    
    try:
        request = ListPublicipsRequest()
        request.limit = 1000
        
        response = client.list_publicips(request)
        
        eips = []
        if response.publicips:
            for eip in response.publicips:
                # 解析创建时间
                created_at = getattr(eip, 'create_time', None)
                created_datetime = None
                if created_at:
                    try:
                        # 处理 ISO 格式时间戳
                        if 'T' in created_at:
                            created_datetime = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
                        else:
                            created_datetime = datetime.strptime(created_at[:19], '%Y-%m-%d %H:%M:%S')
                    except:
                        pass
                
                eip_data = {
                    'id': eip.id,
                    'public_ip_address': eip.public_ip_address,
                    'status': eip.status,
                    'port_id': getattr(eip, 'port_id', None),
                    'bandwidth_size': getattr(eip, 'bandwidth_size', None),
                    'bandwidth_id': getattr(eip, 'bandwidth_id', None),
                    'created_at': created_at,
                    'created_datetime': created_datetime,
                }
                eips.append(eip_data)
        
        return eips
    
    except Exception as e:
        color_print(Colors.RED, f"查询 EIP 失败：{e}")
        return []

def identify_idle_eips(eips: List[dict], idle_days_threshold: int = 7) -> List[dict]:
    """识别闲置 EIP（未绑定且超过阈值天数）"""
    idle = []
    now = datetime.now()
    
    for eip in eips:
        port_id = eip.get('port_id')
        created_datetime = eip.get('created_datetime')
        
        # 未绑定 (port_id 为 None 或空)
        if not port_id or port_id == '':
            # 检查是否超过闲置天数阈值
            if created_datetime:
                days_since_creation = (now - created_datetime).days
                if days_since_creation >= idle_days_threshold:
                    eip['idle_days'] = days_since_creation
                    idle.append(eip)
            else:
                # 无法确定创建时间，默认视为闲置
                eip['idle_days'] = -1  # 未知
                idle.append(eip)
    
    return idle

def send_wechat_webhook(webhook_url: str, title: str, content: str, idle_eips: List[dict]) -> bool:
    """发送企业微信/钉钉 webhook 通知"""
    try:
        # 构建Markdown 消息
        markdown_content = f"## {title}\n\n"
        markdown_content += f"**扫描时间**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
        markdown_content += f"### 📊 发现 {len(idle_eips)} 个闲置 EIP\n\n"
        
        if idle_eips:
            markdown_content += "| EIP ID | IP 地址 | 带宽 | 闲置天数 |\n"
            markdown_content += "|--------|---------|------|----------|\n"
            
            for eip in idle_eips[:10]:  # 最多显示 10 个
                eip_id = eip['id'][:8] + '...'
                ip = eip['public_ip_address']
                bw = f"{eip['bandwidth_size']} Mbps" if eip['bandwidth_size'] else 'N/A'
                idle_days = f"{eip['idle_days']} 天" if eip['idle_days'] > 0 else '未知'
                
                markdown_content += f"| {eip_id} | {ip} | {bw} | {idle_days} |\n"
            
            if len(idle_eips) > 10:
                markdown_content += f"\n... 还有 {len(idle_eips) - 10} 个闲置 EIP\n"
        
        markdown_content += f"\n{content}"
        
        # 企业微信格式
        data = {
            "msgtype": "markdown",
            "markdown": {
                "content": markdown_content
            }
        }
        
        req = urllib.request.Request(
            webhook_url,
            data=json.dumps(data).encode('utf-8'),
            headers={'Content-Type': 'application/json'}
        )
        
        response = urllib.request.urlopen(req, timeout=10)
        result = json.loads(response.read().decode('utf-8'))
        
        # 企业微信返回 errcode 0 表示成功
        if result.get('errcode', 0) == 0 or result.get('code', 0) == 0:
            color_print(Colors.GREEN, "✅ 微信通知发送成功")
            return True
        else:
            color_print(Colors.YELLOW, f"⚠️  微信通知返回异常：{result}")
            return False
            
    except Exception as e:
        color_print(Colors.RED, f"❌ 发送微信通知失败：{e}")
        return False

def send_email_alert(email_to: str, email_smtp: str, email_port: int, email_user: str, email_pass: str, 
                     title: str, content: str, idle_eips: List[dict]) -> bool:
    """发送邮件告警"""
    try:
        # 构建邮件内容
        html_content = f"""
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                table {{ border-collapse: collapse; width: 100%; }}
                th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
                th {{ background-color: #4CAF50; color: white; }}
                tr:nth-child(even) {{ background-color: #f2f2f2; }}
                .warning {{ color: #ff9800; font-weight: bold; }}
            </style>
        </head>
        <body>
            <h2>📊 闲置 EIP 监控告警</h2>
            <p><strong>扫描时间</strong>: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
            <p class="warning">发现 {len(idle_eips)} 个闲置 EIP</p>
            
            <table>
                <tr>
                    <th>EIP ID</th>
                    <th>IP 地址</th>
                    <th>带宽</th>
                    <th>状态</th>
                    <th>闲置天数</th>
                </tr>
        """
        
        for eip in idle_eips[:20]:  # 最多显示 20 个
            eip_id = eip['id'][:8] + '...'
            ip = eip['public_ip_address']
            bw = f"{eip['bandwidth_size']} Mbps" if eip['bandwidth_size'] else 'N/A'
            idle_days = f"{eip['idle_days']} 天" if eip['idle_days'] > 0 else '未知'
            
            html_content += f"""
                <tr>
                    <td>{eip_id}</td>
                    <td>{ip}</td>
                    <td>{bw}</td>
                    <td>{eip['status']}</td>
                    <td class="warning">{idle_days}</td>
                </tr>
            """
        
        html_content += f"""
            </table>
            <p><strong>建议操作</strong>:</p>
            <ul>
                <li>确认这些 EIP 是否确实不再使用</li>
                <li>如确认闲置，请及时释放以节省成本</li>
                <li>如需保留，请绑定到相应资源</li>
            </ul>
            <hr>
            <p style="color: #666; font-size: 12px;">此邮件由华为云 EIP 监控工具自动生成</p>
        </body>
        </html>
        """
        
        msg = MIMEText(html_content, 'html', 'utf-8')
        msg['Subject'] = Header(title, 'utf-8')
        msg['From'] = email_user
        msg['To'] = email_to
        
        # 发送邮件
        server = smtplib.SMTP_SSL(email_smtp, email_port)
        server.login(email_user, email_pass)
        server.sendmail(email_user, [email_to], msg.as_string())
        server.quit()
        
        color_print(Colors.GREEN, "✅ 邮件告警发送成功")
        return True
        
    except Exception as e:
        color_print(Colors.RED, f"❌ 发送邮件告警失败：{e}")
        return False

def print_idle_eips_report(idle_eips: List[dict], region: str):
    """打印闲置 EIP 报告"""
    if not idle_eips:
        color_print(Colors.GREEN, "\n✅ 未发现闲置 EIP，所有 EIP 都在使用中")
        return
    
    print("\n" + "=" * 100)
    print(f"⚠️  闲置 EIP 监控报告 (区域：{region})")
    print("=" * 100)
    print(f"扫描时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"发现闲置 EIP 数量：{len(idle_eips)} 个")
    print("=" * 100)
    print(f"{'EIP ID':<40} {'IP 地址':<16} {'带宽':<10} {'状态':<10} {'闲置天数':<10} {'创建时间'}")
    print("-" * 100)
    
    for eip in idle_eips:
        eip_id = eip.get('id', 'N/A')[:38]
        ip = eip.get('public_ip_address', 'N/A')
        bw_size = eip.get('bandwidth_size', 'N/A')
        status = eip.get('status', 'UNKNOWN')
        idle_days = f"{eip.get('idle_days', 'N/A')} 天" if eip.get('idle_days', -1) > 0 else "未知"
        created_at = eip.get('created_at', 'N/A')
        if created_at and created_at != 'N/A':
            created_at = created_at.replace('T', ' ').split('.')[0][:19]
        
        bw_display = f"{bw_size} Mbps" if bw_size else "N/A"
        
        print(f"{eip_id:<40} {ip:<16} {bw_display:<10} {status:<10} {idle_days:<10} {created_at}")
    
    print("-" * 100)
    
    # 估算成本浪费
    total_bandwidth = sum(eip.get('bandwidth_size', 0) or 0 for eip in idle_eips)
    color_print(Colors.YELLOW, f"\n💰 估算带宽资源浪费：{total_bandwidth} Mbps")
    color_print(Colors.RED, f"⚠️  建议及时释放或绑定这些闲置 EIP 以节省成本")
    print("=" * 100)

def setup_cron_job(webhook_url: Optional[str] = None, email: Optional[str] = None):
    """设置定时监控任务"""
    color_print(Colors.BLUE, "\n📅 设置定时监控任务...")
    
    # 生成 cron 命令
    script_path = os.path.abspath(__file__)
    cron_command = f"0 9 * * * cd {os.path.dirname(script_path)} && python3 {script_path} --scan"
    
    if webhook_url:
        cron_command += f" --wechat-webhook '{webhook_url}'"
    if email:
        cron_command += f" --email '{email}'"
    
    color_print(Colors.YELLOW, "\n📋 请手动添加以下 cron 任务：")
    print(f"\n{cron_command}\n")
    
    color_print(Colors.BLUE, "或者运行以下命令自动添加：")
    print(f"\n(crontab -l 2>/dev/null; echo '{cron_command}') | crontab -\n")
    
    # 尝试自动添加
    try:
        import subprocess
        result = subprocess.run(
            f"(crontab -l 2>/dev/null; echo '{cron_command}') | crontab -",
            shell=True,
            capture_output=True,
            text=True
        )
        if result.returncode == 0:
            color_print(Colors.GREEN, "✅ 定时任务已成功添加")
            color_print(Colors.BLUE, "📅 监控时间：每天早上 9:00 自动扫描")
        else:
            color_print(Colors.YELLOW, f"⚠️  自动添加失败：{result.stderr}")
            color_print(Colors.BLUE, "请手动执行上面的 crontab 命令")
    except Exception as e:
        color_print(Colors.YELLOW, f"⚠️  自动添加失败：{e}")
        color_print(Colors.BLUE, "请手动执行 crontab -e 添加上述任务")

def main():
    parser = argparse.ArgumentParser(description='闲置 EIP 监控与告警工具')
    parser.add_argument('--scan', action='store_true', help='扫描闲置 EIP')
    parser.add_argument('--idle-days', type=int, default=7, help='闲置天数阈值（默认：7 天）')
    parser.add_argument('--wechat-webhook', type=str, help='企业微信/钉钉 webhook URL')
    parser.add_argument('--email', type=str, help='告警邮箱地址')
    parser.add_argument('--email-smtp', type=str, default='smtp.163.com', help='SMTP 服务器（默认：smtp.163.com）')
    parser.add_argument('--email-port', type=int, default=465, help='SMTP 端口（默认：465）')
    parser.add_argument('--email-user', type=str, help='SMTP 登录用户名')
    parser.add_argument('--email-pass', type=str, help='SMTP 登录密码/授权码')
    parser.add_argument('--setup-cron', action='store_true', help='设置定时监控任务')
    
    args = parser.parse_args()
    
    # 设置定时任务模式
    if args.setup_cron:
        setup_cron_job(args.wechat_webhook, args.email)
        return
    
    # 扫描模式
    if not args.scan:
        parser.print_help()
        print("\n错误：请指定操作模式 (--scan / --setup-cron)")
        sys.exit(1)
    
    # 创建客户端
    client, region = get_client()
    
    color_print(Colors.BLUE, f"🔍 正在扫描区域 {region} 的闲置 EIP...")
    
    # 查询所有 EIP
    all_eips = list_all_eips(client)
    
    if not all_eips:
        color_print(Colors.YELLOW, "ℹ️  未找到任何 EIP")
        return
    
    # 识别闲置 EIP
    idle_eips = identify_idle_eips(all_eips, args.idle_days)
    
    # 打印报告
    print_idle_eips_report(idle_eips, region)
    
    # 发送告警通知
    if idle_eips:
        title = f"⚠️  闲置 EIP 告警 - 发现 {len(idle_eips)} 个闲置 EIP"
        content = "请及时处理闲置 EIP 以节省成本。"
        
        # 微信通知
        if args.wechat_webhook:
            send_wechat_webhook(args.wechat_webhook, title, content, idle_eips)
        
        # 邮件通知
        if args.email:
            if not args.email_user or not args.email_pass:
                color_print(Colors.RED, "❌ 发送邮件需要 --email-user 和 --email-pass 参数")
            else:
                send_email_alert(
                    args.email,
                    args.email_smtp,
                    args.email_port,
                    args.email_user,
                    args.email_pass,
                    title,
                    content,
                    idle_eips
                )
    else:
        color_print(Colors.GREEN, "\n✅ 所有 EIP 使用正常，无需告警")

if __name__ == '__main__':
    main()