Huawei Cloud Monitoring Query

huaweicloudsdkcore>=3.1.0
huaweicloudsdkiam>=3.1.0
huaweicloudsdkces>=3.1.0
huaweicloudsdkeps>=3.1.0

import argparse
import sys
import os



sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import ListAgentDimensionInfoRequest, CesClient
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询Agent维度信息列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--instance_id", type=str, required=True, help="ECS实例ID（36位），可通过 scripts/ecs/list_servers_details.py 获取")
parser.add_argument("--dim_name", type=str, required=True, help="维度名称，枚举值：mount_point(挂载点)/disk(磁盘)/proc(进程)/gpu(显卡)/raid(RAID控制器)")
parser.add_argument("--dim_value", type=str, help="维度值，32位字符串")
parser.add_argument("--offset", type=int, help="分页偏移量，最小值0，最大值2147483647，默认0")
parser.add_argument("--limit", type=int, help="分页大小，最小值1，最大值1000，默认1000")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListAgentDimensionInfoRequest()
    request.instance_id = args.instance_id
    request.dim_name = args.dim_name
    if args.dim_value:
        request.dim_value = args.dim_value
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_agent_dimension_info(request)

    dimensions = getattr(response, 'dimensions', []) or []
    count = getattr(response, 'count', 0)

    if not dimensions:
        print("查询结果为空")
        exit(0)

    output = f"Agent维度信息列表（共{count}个）:\n"
    
    for dim in dimensions:
        name = getattr(dim, 'name', '')
        value = getattr(dim, 'value', '')
        origin_value = getattr(dim, 'origin_value', '')
        output += f"维度名称: {name}, 维度值: {value}, 实际维度信息: {origin_value}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_agent_dimension_info 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import ListAlarmHistoriesRequest, CesClient
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警历史列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--alarm_id", type=str, help="告警ID，多个用逗号分隔，可通过 list_alarm_rules.py 获取，最多50个")
parser.add_argument("--record_id", type=str, help="告警流水号，以ah开头，后跟22位字母或数字，长度24")
parser.add_argument("--name", type=str, help="告警规则名称(支持模糊匹配)，最大128字符")
parser.add_argument("--status", type=str, help="告警状态，多个用逗号分隔：ok(已解决)/alarm(告警中)/invalid(已失效)/insufficient_data(数据不足)/ok_manual(已解决手动)，最多3个")
parser.add_argument("--level", type=int, help="告警级别：1紧急/2重要/3次要/4提示")
parser.add_argument("--namespace", type=str, help="服务命名空间，格式service.item，长度3-32")
parser.add_argument("--resource_id", type=str, help="告警资源ID，多维度按字母升序逗号分隔，长度0-2048")
parser.add_argument("--from_time", type=str, help="查询起始更新时间，格式：2022-02-10T10:05:46+08:00。必须与to_time同时使用")
parser.add_argument("--to_time", type=str, help="查询截止更新时间，格式：2022-02-10T10:05:47+08:00。必须与from_time同时使用")
parser.add_argument("--alarm_type", type=str, help="告警类型：event(事件类型)/metric(指标类型)")
parser.add_argument("--create_time_from", type=str, help="查询起始创建时间，格式：2022-02-10T10:05:46+08:00。必须与create_time_to同时使用")
parser.add_argument("--create_time_to", type=str, help="查询截止创建时间，格式：2022-02-10T10:05:47+08:00。必须与create_time_from同时使用")
parser.add_argument("--offset", type=int, help="分页偏移量，最小0，最大1000000000，默认0")
parser.add_argument("--limit", type=int, default=100, help="分页大小，最小1，最大100，默认100")
parser.add_argument("--order_by", type=str, help="排序字段，枚举值：first_alarm_time/update_time/alarm_level/record_id，默认update_time")
parser.add_argument("--mask_status", type=str, help="屏蔽状态，枚举值：UN_MASKED(活跃告警)/MASKED(屏蔽告警)")
args = parser.parse_args()

if (args.from_time is not None) != (args.to_time is not None):
    parser.error("from_time 和 to_time 必须同时指定或同时不指定")

if (args.create_time_from is not None) != (args.create_time_to is not None):
    parser.error("create_time_from 和 create_time_to 必须同时指定或同时不指定")

if args.region is not None:
    Region = args.region

try:
    request = ListAlarmHistoriesRequest()
    if args.alarm_id:
        request.alarm_id = args.alarm_id.split(',')
    if args.record_id:
        request.record_id = args.record_id
    if args.name:
        request.name = args.name
    if args.status:
        request.status = args.status.split(',')
    if args.level is not None:
        request.level = args.level
    if args.namespace:
        request.namespace = args.namespace
    if args.resource_id:
        request.resource_id = args.resource_id
    if args.from_time:
        request._from = args.from_time
    if args.to_time:
        request.to = args.to_time
    if args.alarm_type:
        request.alarm_type = args.alarm_type
    if args.create_time_from:
        request.create_time_from = args.create_time_from
    if args.create_time_to:
        request.create_time_to = args.create_time_to
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit
    if args.order_by:
        request.order_by = args.order_by
    if args.mask_status:
        request.mask_status = args.mask_status

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_alarm_histories(request)

    alarm_histories = getattr(response, 'alarm_histories', []) or []
    count = getattr(response, 'count', 0)

    if not alarm_histories:
        print("查询结果为空")
        exit(0)

    output = f"告警历史列表（共{count}个）:\n"
    output += "流水号\t告警ID\t名称\t状态\t级别\t告警类型\t开始时间\t结束时间\n"
    
    for history in alarm_histories:
        record_id = getattr(history, 'record_id', '')
        alarm_id = getattr(history, 'alarm_id', '')
        name = getattr(history, 'name', '')
        status = getattr(history, 'status', '')
        level = getattr(history, 'level', '')
        alarm_type = getattr(history, 'type', '')
        begin_time = getattr(history, 'begin_time', '')
        end_time = getattr(history, 'end_time', '')
        output += f"{record_id}\t{alarm_id}\t{name}\t{status}\t{level}\t{alarm_type}\t{begin_time}\t{end_time}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_alarm_histories 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import ListAlarmRulePoliciesRequest, CesClient
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警规则绑定的告警策略列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--alarm_id", type=str, required=True, help="告警规则ID，以al开头，后跟22个数字或字母，长度24，可通过 list_alarm_rules.py 获取")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=50, help="分页大小，范围1-100，默认50")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListAlarmRulePoliciesRequest()
    request.alarm_id = args.alarm_id
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_alarm_rule_policies(request)

    policies = getattr(response, 'policies', []) or []
    count = getattr(response, 'count', 0)

    if not policies:
        print("查询结果为空")
        exit(0)

    output = f"告警规则 {args.alarm_id} 绑定的策略列表（共{count}个）:\n"
    output += "指标名称\t命名空间\t维度名称\t聚合方式\t比较运算符\t阈值\t单位\t触发次数\t告警级别\n"
    
    for policy in policies:
        metric_name = getattr(policy, 'metric_name', '')
        namespace = getattr(policy, 'namespace', '')
        dimension_name = getattr(policy, 'dimension_name', '')
        filter = getattr(policy, 'filter', '')
        comparison_operator = getattr(policy, 'comparison_operator', '')
        value = getattr(policy, 'value', '')
        unit = getattr(policy, 'unit', '')
        policy_count = getattr(policy, 'count', '')
        level = getattr(policy, 'level', '')
        output += f"{metric_name}\t{namespace}\t{dimension_name}\t{filter}\t{comparison_operator}\t{value}\t{unit}\t{policy_count}\t{level}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_alarm_rule_policies 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListAlarmRuleResourcesRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警规则关联的资源列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--alarm_id", type=str, required=True, help="告警规则ID，以al开头，后跟22位字母或数字，长度24，可通过 list_alarm_rules.py 获取")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=50, help="分页大小，范围1-100，默认50")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListAlarmRuleResourcesRequest()
    request.alarm_id = args.alarm_id
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_alarm_rule_resources(request)

    resources = getattr(response, 'resources', []) or []
    count = getattr(response, 'count', 0)

    if not resources:
        print("查询结果为空")
        exit(0)

    output = f"告警规则 {args.alarm_id} 关联资源列表（共{count}个）:\n"
    
    for idx, resource in enumerate(resources, 1):
        output += f"资源 {idx}:\n"
        if isinstance(resource, list):
            for dim in resource:
                name = getattr(dim, 'name', '')
                value = getattr(dim, 'value', '')
                output += f"  {name}: {value}\n"
        else:
            output += f"  {str(resource)}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_alarm_rule_resources 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListAlarmRulesRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警规则列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--alarm_id", type=str, help="告警规则ID，以al开头，后跟22位字母或数字，长度24")
parser.add_argument("--name", type=str, help="告警规则名称(支持模糊匹配)，长度1-128")
parser.add_argument("--namespace", type=str, help="服务命名空间，格式service.item")
parser.add_argument("--resource_id", type=str, help="告警资源ID，多维度按字母升序逗号分隔，长度0-700")
parser.add_argument("--enterprise_project_id", type=str, help="企业项目ID，长度36，也可为0或all_granted_eps，可通过 ../eps/list_enterprise_projects.py 获取")
parser.add_argument("--product_name", type=str, help="云产品名称，如SYS.ECS,instance_id，长度0-128")
parser.add_argument("--resource_level", type=str, help="资源层级，枚举值：product(云产品)/dimension(子维度)")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=50, help="分页大小，范围1-100，默认50")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListAlarmRulesRequest()
    if args.alarm_id:
        request.alarm_id = args.alarm_id
    if args.name:
        request.name = args.name
    if args.namespace:
        request.namespace = args.namespace
    if args.resource_id:
        request.resource_id = args.resource_id
    if args.enterprise_project_id:
        request.enterprise_project_id = args.enterprise_project_id
    if args.product_name:
        request.product_name = args.product_name
    if args.resource_level:
        request.resource_level = args.resource_level
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_alarm_rules(request)

    alarms = getattr(response, 'alarms', []) or []
    count = getattr(response, 'count', 0)

    if not alarms:
        print("查询结果为空")
        exit(0)

    output = f"告警规则列表（共{count}个）:\n"
    output += "告警ID\t名称\t是否启用\t是否通知\t命名空间\t告警类型\n"
    
    for alarm in alarms:
        alarm_id = getattr(alarm, 'alarm_id', '')
        name = getattr(alarm, 'name', '')
        enabled = getattr(alarm, 'enabled', False)
        notification_enabled = getattr(alarm, 'notification_enabled', False)
        namespace = getattr(alarm, 'namespace', '')
        alarm_type = getattr(alarm, 'type', '')
        output += f"{alarm_id}\t{name}\t{'启用' if enabled else '禁用'}\t{'启用' if notification_enabled else '禁用'}\t{namespace}\t{alarm_type}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_alarm_rules 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListAlarmTemplateAssociationAlarmsRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警模板关联的告警规则列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--alarm_template_id", type=str, required=True, help="告警模板ID，以at开头，后跟字母、数字，长度2-64，可通过 list_alarm_templates.py 获取")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=100, help="分页大小，范围1-100，默认100")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListAlarmTemplateAssociationAlarmsRequest()
    request.template_id = args.alarm_template_id
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_alarm_template_association_alarms(request)

    alarms = getattr(response, 'alarms', []) or []
    count = getattr(response, 'count', 0)

    if not alarms:
        print("查询结果为空")
        exit(0)

    output = f"告警模板 {args.alarm_template_id} 关联的告警规则列表（共{count}个）:\n"
    output += "告警ID\t名称\t描述\n"
    
    for alarm in alarms:
        alarm_id = getattr(alarm, 'alarm_id', '')
        name = getattr(alarm, 'name', '')
        description = getattr(alarm, 'description', '')
        output += f"{alarm_id}\t{name}\t{description}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_alarm_template_association_alarms 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListAlarmTemplatesRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警模板列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=100, help="分页大小，范围1-100，默认100")
parser.add_argument("--namespace", type=str, help="服务命名空间，格式service.item，长度3-32")
parser.add_argument("--dim_name", type=str, help="资源维度名称，多维度用逗号分隔，每个维度最大长度32，总长度1-131")
parser.add_argument("--template_type", type=str, help="模板类型，枚举值：system/custom/system_event/custom_event/system_custom_event")
parser.add_argument("--template_name", type=str, help="告警模板名称，以字母或汉字开头，长度1-128，支持模糊匹配")
parser.add_argument("--product_name", type=str, help="产品层级跨维规则产品名称，如SYS.ECS,instance_id，长度0-128")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListAlarmTemplatesRequest()
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit
    if args.namespace:
        request.namespace = args.namespace
    if args.dim_name:
        request.dim_name = args.dim_name
    if args.template_type:
        request.template_type = args.template_type
    if args.template_name:
        request.template_name = args.template_name
    if args.product_name:
        request.product_name = args.product_name

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_alarm_templates(request)

    alarm_templates = getattr(response, 'alarm_templates', []) or []
    count = getattr(response, 'count', 0)

    if not alarm_templates:
        print("查询结果为空")
        exit(0)

    output = f"告警模板列表（共{count}个）:\n"
    output += "模板ID\t名称\t类型\t创建时间\t描述\n"
    
    for template in alarm_templates:
        template_id = getattr(template, 'template_id', '')
        template_name = getattr(template, 'template_name', '')
        template_type = getattr(template, 'template_type', '')
        create_time = getattr(template, 'create_time', '')
        template_description = getattr(template, 'template_description', '')
        output += f"{template_id}\t{template_name}\t{template_type}\t{create_time}\t{template_description}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_alarm_templates 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListCesTargetProjectTagsRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询CES目标项目标签列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--resource_type", type=str, default="CES-alarm", help="资源类型，固定为CES-alarm（告警规则），长度1-32")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListCesTargetProjectTagsRequest()
    request.resource_type = args.resource_type

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_ces_target_project_tags(request)

    tags = getattr(response, 'tags', []) or []

    if not tags:
        print("查询结果为空")
        exit(0)

    output = "CES目标项目标签列表:\n"
    output += "键\t值列表\n"
    
    for tag in tags:
        key = getattr(tag, 'key', '')
        values = getattr(tag, 'values', []) or []
        output += f"{key}\t{','.join(str(v) for v in values)}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_ces_target_project_tags 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListDashboardInfosRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询仪表盘列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--enterprise_id", type=str, help="企业项目ID，长度36，也可为0(默认企业项目)或all_granted_eps(所有企业项目)")
parser.add_argument("--is_favorite", type=str, help="监控看板是否收藏，枚举值：true(收藏)/false(未收藏)。填此参数时enterprise_id必填")
parser.add_argument("--dashboard_name", type=str, help="监控看板名称(支持模糊匹配)，长度1-128，只允许中文、英文、数字0-9、_和-")
parser.add_argument("--dashboard_id", type=str, help="监控看板ID，以db开头，包含22个字母和数字，长度24")
parser.add_argument("--dashboard_type", type=str, help="监控看板类型，枚举值：monitor_dashboard(监控大盘)/other(自定义看板)")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListDashboardInfosRequest()
    if args.enterprise_id:
        request.enterprise_id = args.enterprise_id
    if args.is_favorite:
        request.is_favorite = args.is_favorite.lower() == 'true'
    if args.dashboard_name:
        request.dashboard_name = args.dashboard_name
    if args.dashboard_id:
        request.dashboard_id = args.dashboard_id
    if args.dashboard_type:
        request.dashboard_type = args.dashboard_type

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_dashboard_infos(request)

    dashboards = getattr(response, 'dashboards', []) or []

    if not dashboards:
        print("查询结果为空")
        exit(0)

    output = f"仪表盘列表（共{len(dashboards)}个）:\n"
    output += "仪表盘ID\t名称\t是否收藏\t企业项目ID\t创建时间\n"
    
    for dashboard in dashboards:
        dashboard_id = getattr(dashboard, 'dashboard_id', '')
        dashboard_name = getattr(dashboard, 'dashboard_name', '')
        is_favorite = getattr(dashboard, 'is_favorite', False)
        enterprise_id = getattr(dashboard, 'enterprise_id', '')
        create_time = getattr(dashboard, 'create_time', '')
        output += f"{dashboard_id}\t{dashboard_name}\t{'是' if is_favorite else '否'}\t{enterprise_id}\t{create_time}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_dashboard_infos 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListDashboardWidgetsRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询仪表盘组件列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--dashboard_id", type=str, required=True, help="监控看板ID，以db开头，包含22个字母和数字，长度24，可通过 list_dashboard_infos.py 获取")
parser.add_argument("--group_id", type=str, help="视图分组ID，以dg开头包含22个字母和数字长度24，或default(不分组)")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListDashboardWidgetsRequest()
    request.dashboard_id = args.dashboard_id
    if args.group_id:
        request.group_id = args.group_id

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_dashboard_widgets(request)

    widgets = getattr(response, 'widgets', []) or []

    if not widgets:
        print("查询结果为空")
        exit(0)

    output = f"监控看板 {args.dashboard_id} 的视图列表:\n"
    output += "视图ID\t标题\t图表类型\t分组ID\t单位\n"
    
    for widget in widgets:
        widget_id = getattr(widget, 'widget_id', '')
        title = getattr(widget, 'title', '')
        view = getattr(widget, 'view', '')
        group_id = getattr(widget, 'group_id', '')
        unit = getattr(widget, 'unit', '')
        output += f"{widget_id}\t{title}\t{view}\t{group_id}\t{unit}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_dashboard_widgets 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListNotificationMaskResourcesRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询通知屏蔽规则关联的资源列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--notification_mask_id", type=str, required=True, help="屏蔽规则ID，只能包含字母和数字，长度1-64，可通过 list_notification_masks.py 获取")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=100, help="分页大小，范围1-100，默认100")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListNotificationMaskResourcesRequest()
    request.notification_mask_id = args.notification_mask_id
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_notification_mask_resources(request)

    resources = getattr(response, 'resources', []) or []
    count = getattr(response, 'count', 0)

    if not resources:
        print("查询结果为空")
        exit(0)

    output = f"屏蔽规则 {args.notification_mask_id} 关联的资源列表（共{count}个）:\n"
    
    for idx, resource in enumerate(resources, 1):
        namespace = getattr(resource, 'namespace', '')
        dimensions = getattr(resource, 'dimensions', []) or []
        output += f"资源 {idx} (命名空间: {namespace}):\n"
        for dim in dimensions:
            name = getattr(dim, 'name', '')
            value = getattr(dim, 'value', '')
            output += f"  {name}: {value}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_notification_mask_resources 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListNotificationMasksRequest, ListNotificationMaskRequestBody, ListRelationType
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询通知屏蔽规则列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=100, help="分页大小，范围1-100，默认100")
parser.add_argument("--sort_key", type=str, help="排序关键字，与sort_dir同时使用，枚举值：create_time(按创建时间)/update_time(按修改时间)")
parser.add_argument("--sort_dir", type=str, help="排序顺序，与sort_key同时使用，枚举值：DESC(降序)/ASC(升序)")
parser.add_argument("--mask_id", type=str, help="屏蔽规则ID，以nm开头，后跟0-62位字母或数字")
parser.add_argument("--mask_name", type=str, help="屏蔽规则名称，字母/数字/汉字/-/_，长度1-64")
parser.add_argument("--mask_status", type=str, help="屏蔽状态，枚举值：MASK_EFFECTIVE(已生效)/MASK_INEFFECTIVE(未生效)")
parser.add_argument("--relation_type", type=str, default="ALARM_RULE", help="关联类型，枚举值：ALARM_RULE/DEFAULT/RESOURCE/RESOURCE_POLICY_ALARM/RESOURCE_POLICY_NOTIFICATION，默认ALARM_RULE")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListNotificationMasksRequest()
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit
    if args.sort_key:
        request.sort_key = args.sort_key
    if args.sort_dir:
        request.sort_dir = args.sort_dir

    body = ListNotificationMaskRequestBody()
    relation_type_map = {
        "ALARM_RULE": ListRelationType.ALARM_RULE,
        "DEFAULT": ListRelationType.DEFAULT,
        "RESOURCE": ListRelationType.RESOURCE,
        "RESOURCE_POLICY_ALARM": ListRelationType.RESOURCE_POLICY_ALARM,
        "RESOURCE_POLICY_NOTIFICATION": ListRelationType.RESOURCE_POLICY_NOTIFICATION,
    }
    body.relation_type = relation_type_map.get(args.relation_type, ListRelationType.ALARM_RULE)
    if args.mask_id:
        body.mask_id = args.mask_id
    if args.mask_name:
        body.mask_name = args.mask_name
    if args.mask_status:
        body.mask_status = args.mask_status
    request.body = body

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_notification_masks(request)

    masks = getattr(response, 'notification_masks', []) or []
    count = getattr(response, 'count', 0)

    if not masks:
        print("查询结果为空")
        exit(0)

    output = f"通知屏蔽规则列表（共{count}个）:\n"
    output += "屏蔽规则ID\t名称\t状态\t屏蔽类型\t起始日期\t起始时间\t截止日期\t截止时间\n"
    
    for mask in masks:
        notification_mask_id = getattr(mask, 'notification_mask_id', '')
        mask_name = getattr(mask, 'mask_name', '')
        mask_status = getattr(mask, 'mask_status', '')
        mask_type = getattr(mask, 'mask_type', '')
        start_date = getattr(mask, 'start_date', '')
        start_time = getattr(mask, 'start_time', '')
        end_date = getattr(mask, 'end_date', '')
        end_time = getattr(mask, 'end_time', '')
        output += f"{notification_mask_id}\t{mask_name}\t{mask_status}\t{mask_type}\t{start_date}\t{start_time}\t{end_date}\t{end_time}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_notification_masks 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListOneClickAlarmRulesRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询一键告警规则列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--one_click_alarm_id", type=str, required=True, help="一键告警ID，以服务名+OneClickAlarm命名，可通过 list_one_click_alarms.py 获取")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListOneClickAlarmRulesRequest()
    request.one_click_alarm_id = args.one_click_alarm_id

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_one_click_alarm_rules(request)

    alarms = getattr(response, 'alarms', []) or []

    if not alarms:
        print("查询结果为空")
        exit(0)

    output = f"一键告警 {args.one_click_alarm_id} 的告警规则列表:\n"
    output += "告警ID\t名称\t是否启用\n"
    
    for alarm in alarms:
        alarm_id = getattr(alarm, 'alarm_id', '')
        name = getattr(alarm, 'name', '')
        enabled = getattr(alarm, 'enabled', False)
        output += f"{alarm_id}\t{name}\t{'启用' if enabled else '禁用'}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_one_click_alarm_rules 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListOneClickAlarmsRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询一键告警列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListOneClickAlarmsRequest()

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_one_click_alarms(request)

    one_click_alarms = getattr(response, 'one_click_alarms', []) or []

    if not one_click_alarms:
        print("查询结果为空")
        exit(0)

    output = "一键告警列表:\n"
    output += "一键告警ID\t命名空间\t描述\t是否启用\n"
    
    for alarm in one_click_alarms:
        one_click_alarm_id = getattr(alarm, 'one_click_alarm_id', '')
        namespace = getattr(alarm, 'namespace', '')
        description = getattr(alarm, 'description', '')
        enabled = getattr(alarm, 'enabled', False)
        output += f"{one_click_alarm_id}\t{namespace}\t{description}\t{'启用' if enabled else '禁用'}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_one_click_alarms 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListResourceGroupsServicesResourcesRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询资源分组服务资源列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--group_id", type=str, required=True, help="资源分组ID，可通过 list_resource_groups.py 获取")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=str, help="分页大小，范围1-1000，默认1000")
parser.add_argument("--service", type=str, help="服务命名空间，格式service.item")
parser.add_argument("--dim_name", type=str, help="资源维度名称，如instance_id")
parser.add_argument("--status", type=str, help="资源状态，枚举值：HEALTHY/UNHEALTHY/NOT_EXIST")
parser.add_argument("--dim_value", type=str, help="资源维度值")
parser.add_argument("--tag", type=str, help="标签，格式key=value")
parser.add_argument("--extend_relation_id", type=str, help="关联编号")
parser.add_argument("--product_name", type=str, help="云产品名称，如SYS.ECS,instance_id")
parser.add_argument("--resource_name", type=str, help="资源名称")
parser.add_argument("--event_status", type=str, help="事件状态，枚举值：HEALTHY/UNHEALTHY/NOT_EXIST")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListResourceGroupsServicesResourcesRequest()
    request.group_id = args.group_id
    if args.offset is not None:
        request.offset = args.offset
    if args.limit:
        request.limit = args.limit
    if args.service:
        request.service = args.service
    if args.dim_name:
        request.dim_name = args.dim_name
    if args.status:
        request.status = args.status
    if args.dim_value:
        request.dim_value = args.dim_value
    if args.tag:
        request.tag = args.tag
    if args.extend_relation_id:
        request.extend_relation_id = args.extend_relation_id
    if args.product_name:
        request.product_name = args.product_name
    if args.resource_name:
        request.resource_name = args.resource_name
    if args.event_status:
        request.event_status = args.event_status

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_resource_groups_services_resources(request)

    resources = getattr(response, 'resources', []) or []
    count = getattr(response, 'count', 0)

    if not resources:
        print("查询结果为空")
        exit(0)

    output = f"资源分组 {args.group_id} 的服务资源列表（共{count}个）:\n"
    
    for idx, resource in enumerate(resources, 1):
        status = getattr(resource, 'status', '')
        resource_name = getattr(resource, 'resource_name', '')
        dimensions = getattr(resource, 'dimensions', []) or []
        output += f"资源 {idx} (状态: {status}, 名称: {resource_name}):\n"
        for dim in dimensions:
            name = getattr(dim, 'name', '')
            value = getattr(dim, 'value', '')
            output += f"  {name}: {value}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_resource_groups_services_resources 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ListResourceGroupsRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询资源分组列表")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--offset", type=int, help="分页偏移量，范围0-10000，默认0")
parser.add_argument("--limit", type=int, default=100, help="分页大小，范围1-100，默认100")
parser.add_argument("--group_name", type=str, help="资源分组名称，长度1-128")
parser.add_argument("--group_id", type=str, help="资源分组ID，以rg开头，长度24")
parser.add_argument("--enterprise_project_id", type=str, help="企业项目ID，长度36，也可为0或all_granted_eps，可通过 ../eps/list_enterprise_projects.py 获取")
parser.add_argument("--type", type=str, help="资源分组类型，枚举值：ECS/ELB/VPC/EVS/AS等")
parser.add_argument("--status", type=str, help="资源状态，枚举值：HEALTHY/UNHEALTHY/NOT_EXIST")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ListResourceGroupsRequest()
    if args.offset is not None:
        request.offset = args.offset
    if args.limit is not None:
        request.limit = args.limit
    if args.group_name:
        request.group_name = args.group_name
    if args.group_id:
        request.group_id = args.group_id
    if args.enterprise_project_id:
        request.enterprise_project_id = args.enterprise_project_id
    if args.type:
        request.type = args.type
    if args.status:
        request.status = args.status

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.list_resource_groups(request)

    groups = getattr(response, 'resource_groups', []) or []
    count = getattr(response, 'count', 0)

    if not groups:
        print("查询结果为空")
        exit(0)

    output = f"资源分组列表（共{count}个）:\n"
    output += "分组ID\t名称\t类型\t状态\n"
    
    for group in groups:
        group_id = getattr(group, 'group_id', '')
        group_name = getattr(group, 'group_name', '')
        type = getattr(group, 'type', '')
        status = getattr(group, 'status', '')
        output += f"{group_id}\t{group_name}\t{type}\t{status}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.list_resource_groups 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ShowAlarmTemplateRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询告警模板详情")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--alarm_template_id", type=str, required=True, help="告警模板ID，以at开头，可通过 list_alarm_templates.py 获取")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ShowAlarmTemplateRequest()
    request.template_id = args.alarm_template_id

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.show_alarm_template(request)

    template_id = getattr(response, 'template_id', '')
    template_name = getattr(response, 'template_name', '')
    template_type = getattr(response, 'template_type', '')
    create_time = getattr(response, 'create_time', '')
    template_description = getattr(response, 'template_description', '')
    policies = getattr(response, 'policies', []) or []

    output = "告警模板详情:\n"
    output += f"模板ID: {template_id}\n"
    output += f"名称: {template_name}\n"
    output += f"类型: {template_type}\n"
    output += f"创建时间: {create_time}\n"
    output += f"描述: {template_description}\n"
    
    if policies:
        output += "策略列表:\n"
        for idx, policy in enumerate(policies, 1):
            metric_name = getattr(policy, 'metric_name', '')
            alarm_level = getattr(policy, 'alarm_level', '')
            namespace = getattr(policy, 'namespace', '')
            output += f"  {idx}. {namespace} - {metric_name} - 级别: {alarm_level}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.show_alarm_template 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ShowResourceGroupRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询资源分组详情")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--group_id", type=str, required=True, help="资源分组ID，可通过 list_resource_groups.py 获取")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ShowResourceGroupRequest()
    request.group_id = args.group_id

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.show_resource_group(request)

    group_id = getattr(response, 'group_id', '')
    group_name = getattr(response, 'group_name', '')
    type = getattr(response, 'type', '')
    status = getattr(response, 'status', '')
    create_time = getattr(response, 'create_time', '')

    output = "资源分组详情:\n"
    output += f"分组ID: {group_id}\n"
    output += f"名称: {group_name}\n"
    output += f"类型: {type}\n"
    output += f"状态: {status}\n"
    output += f"创建时间: {create_time}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.show_resource_group 查询失败: {e}")
    exit(1)

import argparse
import sys
import os

sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))

from config import load_credentials, build_http_config
from huaweicloudsdkcore.auth.credentials import BasicCredentials
from huaweicloudsdkces.v2 import CesClient
from huaweicloudsdkces.v2.model import ShowWidgetRequest
from huaweicloudsdkces.v2.region.ces_region import CesRegion

AK, SK, Region, SecurityToken = load_credentials()

parser = argparse.ArgumentParser(description="查询仪表盘组件详情")
parser.add_argument("--region", type=str, default="cn-north-4", help="区域，默认 cn-north-4")
parser.add_argument("--widget_id", type=str, required=True, help="监控视图ID，以wg开头，长度24，可通过 list_dashboard_widgets.py 获取")
args = parser.parse_args()

if args.region is not None:
    Region = args.region

try:
    request = ShowWidgetRequest()
    request.widget_id = args.widget_id

    http_config = build_http_config()
    client = CesClient.new_builder().with_http_config(http_config).with_credentials(
        BasicCredentials(AK, SK) if not SecurityToken else BasicCredentials(AK, SK).with_security_token(SecurityToken)).with_region(CesRegion.value_of(Region)).build()
    if not client:
        print("无法获取 Ces 客户端")
        exit(-1)

    response = client.show_widget(request)

    widget_id = getattr(response, 'widget_id', '')
    title = getattr(response, 'title', '')
    view = getattr(response, 'view', '')
    unit = getattr(response, 'unit', '')

    output = "监控视图详情:\n"
    output += f"视图ID: {widget_id}\n"
    output += f"标题: {title}\n"
    output += f"图表类型: {view}\n"
    output += f"单位: {unit}\n"

    print(output.strip())
    exit(0)
except Exception as e:
    print(f"ces.show_widget 查询失败: {e}")
    exit(1)