# -*- coding: utf-8 -*-
import os
import sys
import six
import json
import tccli.options_define as OptionsDefine
import tccli.format_output as FormatOutput
from tccli import __version__
from tccli.utils import Utils
from tccli.exceptions import ConfigurationError, ClientError, ParamError
from tencentcloud.common import credential
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.dayu.v20180709 import dayu_client as dayu_client_v20180709
from tencentcloud.dayu.v20180709 import models as models_v20180709

from jmespath import search
import time

def doModifyCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeRuleSets(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeRuleSetsRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeRuleSets(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateNewL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNewL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNewL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7CCRule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7CCRuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7CCRule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribleL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCPolicySwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCPolicySwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCPolicySwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL4Health(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4HealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Health(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSUsedStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSUsedStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSUsedStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribePcap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePcapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePcap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyElasticLimit(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyElasticLimitRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyElasticLimit(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeIpBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeSecIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSecIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSecIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeSchedulingDomainList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSchedulingDomainListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSchedulingDomainList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBaradData(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBaradDataRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBaradData(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyResBindDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResBindDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResBindDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyNetReturnSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNetReturnSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNetReturnSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeSourceIpSegment(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSourceIpSegmentRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSourceIpSegment(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBasicDeviceThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicDeviceThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicDeviceThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateUnblockIp(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateUnblockIpRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateUnblockIp(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyNewL4Rule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewL4RuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewL4Rule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBizHttpStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBizHttpStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBizHttpStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribePolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeActionLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeActionLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeActionLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribePackIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePackIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePackIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateBasicDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBasicDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBasicDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7RuleCert(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RuleCertRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RuleCert(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSAIStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAIStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAIStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeResourceList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResourceListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResourceList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateBoundIP(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBoundIPRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBoundIP(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL4KeepTime(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4KeepTimeRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4KeepTime(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeL4RulesErrHealth(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4RulesErrHealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4RulesErrHealth(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeTransmitStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeTransmitStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeTransmitStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeUnBlockStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeUnBlockStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeUnBlockStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateNetReturn(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNetReturnRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNetReturn(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackSource(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackSourceRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackSource(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSWaterKey(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSWaterKeyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSWaterKey(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeInsurePacks(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeInsurePacksRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeInsurePacks(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCHostProtection(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCHostProtectionRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCHostProtection(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribleRegionCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleRegionCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleRegionCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeIpUnBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpUnBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpUnBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeIPProductInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIPProductInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIPProductInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRulesStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRulesStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribleL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyNewDomainRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewDomainRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewDomainRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBasicCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeResIpList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResIpListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResIpList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateInstanceName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateInstanceNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateInstanceName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBGPIPL7RuleMaxCnt(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBGPIPL7RuleMaxCntRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBGPIPL7RuleMaxCnt(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyResourceRenewFlag(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResourceRenewFlagRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResourceRenewFlag(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackIPRegionMap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackIPRegionMapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackIPRegionMap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


CLIENT_MAP = {
    "v20180709": dayu_client_v20180709,

}

MODELS_MAP = {
    "v20180709": models_v20180709,

}

ACTION_MAP = {
    "ModifyCCIpAllowDeny": doModifyCCIpAllowDeny,
    "DescribeDDoSCount": doDescribeDDoSCount,
    "DescribeRuleSets": doDescribeRuleSets,
    "CreateNewL7RulesUpload": doCreateNewL7RulesUpload,
    "CreateL7CCRule": doCreateL7CCRule,
    "CreateCCSelfDefinePolicy": doCreateCCSelfDefinePolicy,
    "DescribleL7Rules": doDescribleL7Rules,
    "ModifyCCPolicySwitch": doModifyCCPolicySwitch,
    "CreateDDoSPolicyCase": doCreateDDoSPolicyCase,
    "DescribeDDoSNetTrend": doDescribeDDoSNetTrend,
    "ModifyDDoSPolicyName": doModifyDDoSPolicyName,
    "ModifyL4Health": doModifyL4Health,
    "DescribeDDoSUsedStatis": doDescribeDDoSUsedStatis,
    "DescribeDDoSDefendStatus": doDescribeDDoSDefendStatus,
    "DescribeCCAlarmThreshold": doDescribeCCAlarmThreshold,
    "DescribePcap": doDescribePcap,
    "ModifyElasticLimit": doModifyElasticLimit,
    "DescribeDDoSNetIpLog": doDescribeDDoSNetIpLog,
    "ModifyCCAlarmThreshold": doModifyCCAlarmThreshold,
    "DescribeDDoSEvList": doDescribeDDoSEvList,
    "DescribeIpBlockList": doDescribeIpBlockList,
    "DescribeL4HealthConfig": doDescribeL4HealthConfig,
    "DescribeSecIndex": doDescribeSecIndex,
    "DescribeSchedulingDomainList": doDescribeSchedulingDomainList,
    "DescribeCCFrequencyRules": doDescribeCCFrequencyRules,
    "DeleteDDoSPolicyCase": doDeleteDDoSPolicyCase,
    "DeleteL7Rules": doDeleteL7Rules,
    "CreateL4Rules": doCreateL4Rules,
    "DescribeBaradData": doDescribeBaradData,
    "ModifyCCFrequencyRules": doModifyCCFrequencyRules,
    "CreateDDoSPolicy": doCreateDDoSPolicy,
    "ModifyResBindDDoSPolicy": doModifyResBindDDoSPolicy,
    "ModifyNetReturnSwitch": doModifyNetReturnSwitch,
    "DescribeSourceIpSegment": doDescribeSourceIpSegment,
    "ModifyCCUrlAllow": doModifyCCUrlAllow,
    "DescribeBasicDeviceThreshold": doDescribeBasicDeviceThreshold,
    "CreateUnblockIp": doCreateUnblockIp,
    "ModifyNewL4Rule": doModifyNewL4Rule,
    "DeleteDDoSPolicy": doDeleteDDoSPolicy,
    "DescribeDDoSNetCount": doDescribeDDoSNetCount,
    "DescribeBizHttpStatus": doDescribeBizHttpStatus,
    "DeleteCCSelfDefinePolicy": doDeleteCCSelfDefinePolicy,
    "DescribePolicyCase": doDescribePolicyCase,
    "DescribeActionLog": doDescribeActionLog,
    "ModifyL4Rules": doModifyL4Rules,
    "DescribeDDoSIpLog": doDescribeDDoSIpLog,
    "DescribeDDoSAlarmThreshold": doDescribeDDoSAlarmThreshold,
    "DescribePackIndex": doDescribePackIndex,
    "CreateBasicDDoSAlarmThreshold": doCreateBasicDDoSAlarmThreshold,
    "ModifyDDoSThreshold": doModifyDDoSThreshold,
    "CreateL7RuleCert": doCreateL7RuleCert,
    "ModifyDDoSAIStatus": doModifyDDoSAIStatus,
    "DescribeCCIpAllowDeny": doDescribeCCIpAllowDeny,
    "CreateL4HealthConfig": doCreateL4HealthConfig,
    "DescribeResourceList": doDescribeResourceList,
    "CreateBoundIP": doCreateBoundIP,
    "ModifyDDoSPolicy": doModifyDDoSPolicy,
    "ModifyDDoSPolicyCase": doModifyDDoSPolicyCase,
    "ModifyDDoSAlarmThreshold": doModifyDDoSAlarmThreshold,
    "DescribeDDoSNetEvInfo": doDescribeDDoSNetEvInfo,
    "DeleteCCFrequencyRules": doDeleteCCFrequencyRules,
    "ModifyL4KeepTime": doModifyL4KeepTime,
    "DescribeL4RulesErrHealth": doDescribeL4RulesErrHealth,
    "CreateL7RulesUpload": doCreateL7RulesUpload,
    "DescribeDDoSPolicy": doDescribeDDoSPolicy,
    "DescribeTransmitStatis": doDescribeTransmitStatis,
    "ModifyCCLevel": doModifyCCLevel,
    "ModifyDDoSDefendStatus": doModifyDDoSDefendStatus,
    "DescribeUnBlockStatis": doDescribeUnBlockStatis,
    "DescribeDDoSTrend": doDescribeDDoSTrend,
    "CreateNetReturn": doCreateNetReturn,
    "ModifyDDoSSwitch": doModifyDDoSSwitch,
    "ModifyDDoSLevel": doModifyDDoSLevel,
    "DescribeDDoSAttackSource": doDescribeDDoSAttackSource,
    "DescribeCCEvList": doDescribeCCEvList,
    "ModifyDDoSWaterKey": doModifyDDoSWaterKey,
    "DescribeInsurePacks": doDescribeInsurePacks,
    "DeleteL4Rules": doDeleteL4Rules,
    "DescribeDDoSNetEvList": doDescribeDDoSNetEvList,
    "ModifyCCHostProtection": doModifyCCHostProtection,
    "DescribleRegionCount": doDescribleRegionCount,
    "CreateL7Rules": doCreateL7Rules,
    "DescribeIpUnBlockList": doDescribeIpUnBlockList,
    "DescribeIPProductInfo": doDescribeIPProductInfo,
    "DescribeCCSelfDefinePolicy": doDescribeCCSelfDefinePolicy,
    "ModifyCCFrequencyRulesStatus": doModifyCCFrequencyRulesStatus,
    "ModifyCCThreshold": doModifyCCThreshold,
    "DescribleL4Rules": doDescribleL4Rules,
    "ModifyNewDomainRules": doModifyNewDomainRules,
    "DescribeCCUrlAllow": doDescribeCCUrlAllow,
    "DescribeL7HealthConfig": doDescribeL7HealthConfig,
    "DescribeCCTrend": doDescribeCCTrend,
    "CreateCCFrequencyRules": doCreateCCFrequencyRules,
    "ModifyL7Rules": doModifyL7Rules,
    "DescribeBasicCCThreshold": doDescribeBasicCCThreshold,
    "CreateL7HealthConfig": doCreateL7HealthConfig,
    "DescribeResIpList": doDescribeResIpList,
    "CreateInstanceName": doCreateInstanceName,
    "DescribeBGPIPL7RuleMaxCnt": doDescribeBGPIPL7RuleMaxCnt,
    "ModifyResourceRenewFlag": doModifyResourceRenewFlag,
    "ModifyCCSelfDefinePolicy": doModifyCCSelfDefinePolicy,
    "DescribeDDoSEvInfo": doDescribeDDoSEvInfo,
    "DescribeDDoSAttackIPRegionMap": doDescribeDDoSAttackIPRegionMap,

}

AVAILABLE_VERSION_LIST = [
    "v20180709",

]


def action_caller():
    return ACTION_MAP


def parse_global_arg(parsed_globals):
    g_param = parsed_globals

    is_exist_profile = True
    if not parsed_globals["profile"]:
        is_exist_profile = False
        g_param["profile"] = os.environ.get("TCCLI_PROFILE", "default")

    configure_path = os.path.join(os.path.expanduser("~"), ".tccli")
    is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param["profile"] + ".configure")
    is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param["profile"] + ".credential")

    conf = {}
    cred = {}

    if is_conf_exist:
        conf = Utils.load_json_msg(conf_path)
    if is_cred_exist:
        cred = Utils.load_json_msg(cred_path)

    if not (isinstance(conf, dict) and isinstance(cred, dict)):
        raise ConfigurationError(
            "file: %s or %s is not json format"
            % (g_param["profile"] + ".configure", g_param["profile"] + ".credential"))

    if OptionsDefine.Token not in cred:
        cred[OptionsDefine.Token] = None

    if not is_exist_profile:
        if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(OptionsDefine.ENV_SECRET_KEY):
            cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.ENV_SECRET_ID)
            cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.ENV_SECRET_KEY)
            cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)

        if os.environ.get(OptionsDefine.ENV_REGION):
            conf[OptionsDefine.SysParam][OptionsDefine.Region] = os.environ.get(OptionsDefine.ENV_REGION)

        if os.environ.get(OptionsDefine.ENV_ROLE_ARN) and os.environ.get(OptionsDefine.ENV_ROLE_SESSION_NAME):
            cred[OptionsDefine.RoleArn] = os.environ.get(OptionsDefine.ENV_ROLE_ARN)
            cred[OptionsDefine.RoleSessionName] = os.environ.get(OptionsDefine.ENV_ROLE_SESSION_NAME)

    for param in g_param.keys():
        if g_param[param] is None:
            if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId, OptionsDefine.Token]:
                if param in cred:
                    g_param[param] = cred[param]
                elif not (g_param[OptionsDefine.UseCVMRole.replace('-', '_')]
                          or os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN)):
                    raise ConfigurationError("%s is invalid" % param)
            elif param in [OptionsDefine.Region, OptionsDefine.Output, OptionsDefine.Language]:
                if param in conf[OptionsDefine.SysParam]:
                    g_param[param] = conf[OptionsDefine.SysParam][param]
                elif param != OptionsDefine.Language:
                    raise ConfigurationError("%s is invalid" % param)
            elif param.replace('_', '-') in [OptionsDefine.RoleArn, OptionsDefine.RoleSessionName]:
                if param.replace('_', '-') in cred:
                    g_param[param] = cred[param.replace('_', '-')]

    try:
        if g_param[OptionsDefine.ServiceVersion]:
            g_param[OptionsDefine.Version] = "v" + g_param[OptionsDefine.ServiceVersion].replace('-', '')
        else:
            version = conf["dayu"][OptionsDefine.Version]
            g_param[OptionsDefine.Version] = "v" + version.replace('-', '')

        if g_param[OptionsDefine.Endpoint] is None:
            g_param[OptionsDefine.Endpoint] = conf["dayu"][OptionsDefine.Endpoint]
    except Exception as err:
        raise ConfigurationError("config file:%s error, %s" % (conf_path, str(err)))

    if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
        raise Exception("available versions: %s" % " ".join(AVAILABLE_VERSION_LIST))

    if g_param[OptionsDefine.Waiter]:
        param = eval(g_param[OptionsDefine.Waiter])
        if 'expr' not in param:
            raise Exception('`expr` in `--waiter` must be defined')
        if 'to' not in param:
            raise Exception('`to` in `--waiter` must be defined')
        if 'timeout' not in param:
            if 'waiter' in conf and 'timeout' in conf['waiter']:
                param['timeout'] = conf['waiter']['timeout']
            else:
                param['timeout'] = 180
        if 'interval' not in param:
            if 'waiter' in conf and 'interval' in conf['waiter']:
                param['interval'] = conf['waiter']['interval']
            else:
                param['interval'] = 5
        param['interval'] = min(param['interval'], param['timeout'])
        g_param['OptionsDefine.WaiterInfo'] = param

    if six.PY2:
        for key, value in g_param.items():
            if isinstance(value, six.text_type):
                g_param[key] = value.encode('utf-8')
    return g_param


5fc84351b1fc3a9e5ffae09f60e87ecf428eebc4
<mask token>


def doModifyDDoSPolicyName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSNetIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeSchedulingDomainList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSchedulingDomainListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSchedulingDomainList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDeleteDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyResBindDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResBindDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResBindDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeBasicDeviceThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicDeviceThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicDeviceThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyNewL4Rule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewL4RuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewL4Rule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDeleteCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doCreateBasicDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBasicDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBasicDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyDDoSAIStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAIStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAIStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doCreateBoundIP(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBoundIPRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBoundIP(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSNetEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeL4RulesErrHealth(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4RulesErrHealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4RulesErrHealth(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeTransmitStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeTransmitStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeTransmitStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateNetReturn(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNetReturnRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNetReturn(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyDDoSLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyDDoSWaterKey(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSWaterKeyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSWaterKey(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDeleteL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCHostProtection(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCHostProtectionRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCHostProtection(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleRegionCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleRegionCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleRegionCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeIPProductInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIPProductInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIPProductInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRulesStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRulesStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyNewDomainRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewDomainRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewDomainRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doCreateCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doCreateL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doCreateInstanceName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateInstanceNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateInstanceName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBGPIPL7RuleMaxCnt(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBGPIPL7RuleMaxCntRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBGPIPL7RuleMaxCnt(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResourceRenewFlag(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResourceRenewFlagRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResourceRenewFlag(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackIPRegionMap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackIPRegionMapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackIPRegionMap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def action_caller():
    return ACTION_MAP


def parse_global_arg(parsed_globals):
    g_param = parsed_globals
    is_exist_profile = True
    if not parsed_globals['profile']:
        is_exist_profile = False
        g_param['profile'] = os.environ.get('TCCLI_PROFILE', 'default')
    configure_path = os.path.join(os.path.expanduser('~'), '.tccli')
    is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.configure')
    is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.credential')
    conf = {}
    cred = {}
    if is_conf_exist:
        conf = Utils.load_json_msg(conf_path)
    if is_cred_exist:
        cred = Utils.load_json_msg(cred_path)
    if not (isinstance(conf, dict) and isinstance(cred, dict)):
        raise ConfigurationError('file: %s or %s is not json format' % (
            g_param['profile'] + '.configure', g_param['profile'] +
            '.credential'))
    if OptionsDefine.Token not in cred:
        cred[OptionsDefine.Token] = None
    if not is_exist_profile:
        if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(
            OptionsDefine.ENV_SECRET_KEY):
            cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.
                ENV_SECRET_ID)
            cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.
                ENV_SECRET_KEY)
            cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)
        if os.environ.get(OptionsDefine.ENV_REGION):
            conf[OptionsDefine.SysParam][OptionsDefine.Region
                ] = os.environ.get(OptionsDefine.ENV_REGION)
        if os.environ.get(OptionsDefine.ENV_ROLE_ARN) and os.environ.get(
            OptionsDefine.ENV_ROLE_SESSION_NAME):
            cred[OptionsDefine.RoleArn] = os.environ.get(OptionsDefine.
                ENV_ROLE_ARN)
            cred[OptionsDefine.RoleSessionName] = os.environ.get(OptionsDefine
                .ENV_ROLE_SESSION_NAME)
    for param in g_param.keys():
        if g_param[param] is None:
            if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId,
                OptionsDefine.Token]:
                if param in cred:
                    g_param[param] = cred[param]
                elif not (g_param[OptionsDefine.UseCVMRole.replace('-', '_'
                    )] or os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN)):
                    raise ConfigurationError('%s is invalid' % param)
            elif param in [OptionsDefine.Region, OptionsDefine.Output,
                OptionsDefine.Language]:
                if param in conf[OptionsDefine.SysParam]:
                    g_param[param] = conf[OptionsDefine.SysParam][param]
                elif param != OptionsDefine.Language:
                    raise ConfigurationError('%s is invalid' % param)
            elif param.replace('_', '-') in [OptionsDefine.RoleArn,
                OptionsDefine.RoleSessionName]:
                if param.replace('_', '-') in cred:
                    g_param[param] = cred[param.replace('_', '-')]
    try:
        if g_param[OptionsDefine.ServiceVersion]:
            g_param[OptionsDefine.Version] = 'v' + g_param[OptionsDefine.
                ServiceVersion].replace('-', '')
        else:
            version = conf['dayu'][OptionsDefine.Version]
            g_param[OptionsDefine.Version] = 'v' + version.replace('-', '')
        if g_param[OptionsDefine.Endpoint] is None:
            g_param[OptionsDefine.Endpoint] = conf['dayu'][OptionsDefine.
                Endpoint]
    except Exception as err:
        raise ConfigurationError('config file:%s error, %s' % (conf_path,
            str(err)))
    if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
        raise Exception('available versions: %s' % ' '.join(
            AVAILABLE_VERSION_LIST))
    if g_param[OptionsDefine.Waiter]:
        param = eval(g_param[OptionsDefine.Waiter])
        if 'expr' not in param:
            raise Exception('`expr` in `--waiter` must be defined')
        if 'to' not in param:
            raise Exception('`to` in `--waiter` must be defined')
        if 'timeout' not in param:
            if 'waiter' in conf and 'timeout' in conf['waiter']:
                param['timeout'] = conf['waiter']['timeout']
            else:
                param['timeout'] = 180
        if 'interval' not in param:
            if 'waiter' in conf and 'interval' in conf['waiter']:
                param['interval'] = conf['waiter']['interval']
            else:
                param['interval'] = 5
        param['interval'] = min(param['interval'], param['timeout'])
        g_param['OptionsDefine.WaiterInfo'] = param
    if six.PY2:
        for key, value in g_param.items():
            if isinstance(value, six.text_type):
                g_param[key] = value.encode('utf-8')
    return g_param

<mask token>


def doCreateNewL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNewL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNewL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7CCRule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7CCRuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7CCRule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSNetTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4Health(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4HealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Health(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSNetIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeIpBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeSchedulingDomainList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSchedulingDomainListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSchedulingDomainList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResBindDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResBindDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResBindDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBasicDeviceThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicDeviceThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicDeviceThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyNewL4Rule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewL4RuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewL4Rule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDeleteCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeActionLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeActionLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeActionLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePackIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePackIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePackIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateBasicDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBasicDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBasicDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyDDoSAIStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAIStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAIStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeResourceList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResourceListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResourceList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateBoundIP(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBoundIPRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBoundIP(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4KeepTime(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4KeepTimeRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4KeepTime(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL4RulesErrHealth(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4RulesErrHealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4RulesErrHealth(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeTransmitStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeTransmitStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeTransmitStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateNetReturn(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNetReturnRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNetReturn(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyDDoSLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeCCEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSWaterKey(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSWaterKeyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSWaterKey(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeInsurePacks(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeInsurePacksRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeInsurePacks(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCHostProtection(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCHostProtectionRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCHostProtection(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleRegionCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleRegionCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleRegionCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIpUnBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpUnBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpUnBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIPProductInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIPProductInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIPProductInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRulesStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRulesStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNewDomainRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewDomainRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewDomainRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeBasicCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeResIpList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResIpListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResIpList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateInstanceName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateInstanceNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateInstanceName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBGPIPL7RuleMaxCnt(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBGPIPL7RuleMaxCntRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBGPIPL7RuleMaxCnt(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResourceRenewFlag(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResourceRenewFlagRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResourceRenewFlag(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackIPRegionMap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackIPRegionMapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackIPRegionMap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def action_caller():
    return ACTION_MAP


def parse_global_arg(parsed_globals):
    g_param = parsed_globals
    is_exist_profile = True
    if not parsed_globals['profile']:
        is_exist_profile = False
        g_param['profile'] = os.environ.get('TCCLI_PROFILE', 'default')
    configure_path = os.path.join(os.path.expanduser('~'), '.tccli')
    is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.configure')
    is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.credential')
    conf = {}
    cred = {}
    if is_conf_exist:
        conf = Utils.load_json_msg(conf_path)
    if is_cred_exist:
        cred = Utils.load_json_msg(cred_path)
    if not (isinstance(conf, dict) and isinstance(cred, dict)):
        raise ConfigurationError('file: %s or %s is not json format' % (
            g_param['profile'] + '.configure', g_param['profile'] +
            '.credential'))
    if OptionsDefine.Token not in cred:
        cred[OptionsDefine.Token] = None
    if not is_exist_profile:
        if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(
            OptionsDefine.ENV_SECRET_KEY):
            cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.
                ENV_SECRET_ID)
            cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.
                ENV_SECRET_KEY)
            cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)
        if os.environ.get(OptionsDefine.ENV_REGION):
            conf[OptionsDefine.SysParam][OptionsDefine.Region
                ] = os.environ.get(OptionsDefine.ENV_REGION)
        if os.environ.get(OptionsDefine.ENV_ROLE_ARN) and os.environ.get(
            OptionsDefine.ENV_ROLE_SESSION_NAME):
            cred[OptionsDefine.RoleArn] = os.environ.get(OptionsDefine.
                ENV_ROLE_ARN)
            cred[OptionsDefine.RoleSessionName] = os.environ.get(OptionsDefine
                .ENV_ROLE_SESSION_NAME)
    for param in g_param.keys():
        if g_param[param] is None:
            if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId,
                OptionsDefine.Token]:
                if param in cred:
                    g_param[param] = cred[param]
                elif not (g_param[OptionsDefine.UseCVMRole.replace('-', '_'
                    )] or os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN)):
                    raise ConfigurationError('%s is invalid' % param)
            elif param in [OptionsDefine.Region, OptionsDefine.Output,
                OptionsDefine.Language]:
                if param in conf[OptionsDefine.SysParam]:
                    g_param[param] = conf[OptionsDefine.SysParam][param]
                elif param != OptionsDefine.Language:
                    raise ConfigurationError('%s is invalid' % param)
            elif param.replace('_', '-') in [OptionsDefine.RoleArn,
                OptionsDefine.RoleSessionName]:
                if param.replace('_', '-') in cred:
                    g_param[param] = cred[param.replace('_', '-')]
    try:
        if g_param[OptionsDefine.ServiceVersion]:
            g_param[OptionsDefine.Version] = 'v' + g_param[OptionsDefine.
                ServiceVersion].replace('-', '')
        else:
            version = conf['dayu'][OptionsDefine.Version]
            g_param[OptionsDefine.Version] = 'v' + version.replace('-', '')
        if g_param[OptionsDefine.Endpoint] is None:
            g_param[OptionsDefine.Endpoint] = conf['dayu'][OptionsDefine.
                Endpoint]
    except Exception as err:
        raise ConfigurationError('config file:%s error, %s' % (conf_path,
            str(err)))
    if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
        raise Exception('available versions: %s' % ' '.join(
            AVAILABLE_VERSION_LIST))
    if g_param[OptionsDefine.Waiter]:
        param = eval(g_param[OptionsDefine.Waiter])
        if 'expr' not in param:
            raise Exception('`expr` in `--waiter` must be defined')
        if 'to' not in param:
            raise Exception('`to` in `--waiter` must be defined')
        if 'timeout' not in param:
            if 'waiter' in conf and 'timeout' in conf['waiter']:
                param['timeout'] = conf['waiter']['timeout']
            else:
                param['timeout'] = 180
        if 'interval' not in param:
            if 'waiter' in conf and 'interval' in conf['waiter']:
                param['interval'] = conf['waiter']['interval']
            else:
                param['interval'] = 5
        param['interval'] = min(param['interval'], param['timeout'])
        g_param['OptionsDefine.WaiterInfo'] = param
    if six.PY2:
        for key, value in g_param.items():
            if isinstance(value, six.text_type):
                g_param[key] = value.encode('utf-8')
    return g_param

<mask token>


def doModifyCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeRuleSets(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeRuleSetsRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeRuleSets(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateNewL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNewL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNewL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7CCRule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7CCRuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7CCRule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCPolicySwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCPolicySwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCPolicySwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSNetTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4Health(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4HealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Health(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSUsedStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSUsedStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSUsedStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyElasticLimit(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyElasticLimitRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyElasticLimit(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIpBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeSchedulingDomainList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSchedulingDomainListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSchedulingDomainList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResBindDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResBindDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResBindDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNetReturnSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNetReturnSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNetReturnSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeSourceIpSegment(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSourceIpSegmentRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSourceIpSegment(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBasicDeviceThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicDeviceThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicDeviceThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateUnblockIp(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateUnblockIpRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateUnblockIp(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNewL4Rule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewL4RuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewL4Rule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBizHttpStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBizHttpStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBizHttpStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeActionLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeActionLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeActionLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePackIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePackIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePackIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateBasicDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBasicDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBasicDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7RuleCert(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RuleCertRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RuleCert(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSAIStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAIStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAIStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeResourceList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResourceListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResourceList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateBoundIP(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBoundIPRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBoundIP(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4KeepTime(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4KeepTimeRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4KeepTime(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL4RulesErrHealth(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4RulesErrHealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4RulesErrHealth(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeTransmitStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeTransmitStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeTransmitStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeUnBlockStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeUnBlockStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeUnBlockStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateNetReturn(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNetReturnRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNetReturn(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeCCEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSWaterKey(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSWaterKeyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSWaterKey(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeInsurePacks(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeInsurePacksRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeInsurePacks(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCHostProtection(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCHostProtectionRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCHostProtection(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleRegionCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleRegionCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleRegionCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIpUnBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpUnBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpUnBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIPProductInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIPProductInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIPProductInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRulesStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRulesStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNewDomainRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewDomainRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewDomainRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBasicCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeResIpList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResIpListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResIpList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateInstanceName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateInstanceNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateInstanceName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBGPIPL7RuleMaxCnt(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBGPIPL7RuleMaxCntRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBGPIPL7RuleMaxCnt(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResourceRenewFlag(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResourceRenewFlagRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResourceRenewFlag(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackIPRegionMap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackIPRegionMapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackIPRegionMap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def action_caller():
    return ACTION_MAP


def parse_global_arg(parsed_globals):
    g_param = parsed_globals
    is_exist_profile = True
    if not parsed_globals['profile']:
        is_exist_profile = False
        g_param['profile'] = os.environ.get('TCCLI_PROFILE', 'default')
    configure_path = os.path.join(os.path.expanduser('~'), '.tccli')
    is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.configure')
    is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.credential')
    conf = {}
    cred = {}
    if is_conf_exist:
        conf = Utils.load_json_msg(conf_path)
    if is_cred_exist:
        cred = Utils.load_json_msg(cred_path)
    if not (isinstance(conf, dict) and isinstance(cred, dict)):
        raise ConfigurationError('file: %s or %s is not json format' % (
            g_param['profile'] + '.configure', g_param['profile'] +
            '.credential'))
    if OptionsDefine.Token not in cred:
        cred[OptionsDefine.Token] = None
    if not is_exist_profile:
        if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(
            OptionsDefine.ENV_SECRET_KEY):
            cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.
                ENV_SECRET_ID)
            cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.
                ENV_SECRET_KEY)
            cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)
        if os.environ.get(OptionsDefine.ENV_REGION):
            conf[OptionsDefine.SysParam][OptionsDefine.Region
                ] = os.environ.get(OptionsDefine.ENV_REGION)
        if os.environ.get(OptionsDefine.ENV_ROLE_ARN) and os.environ.get(
            OptionsDefine.ENV_ROLE_SESSION_NAME):
            cred[OptionsDefine.RoleArn] = os.environ.get(OptionsDefine.
                ENV_ROLE_ARN)
            cred[OptionsDefine.RoleSessionName] = os.environ.get(OptionsDefine
                .ENV_ROLE_SESSION_NAME)
    for param in g_param.keys():
        if g_param[param] is None:
            if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId,
                OptionsDefine.Token]:
                if param in cred:
                    g_param[param] = cred[param]
                elif not (g_param[OptionsDefine.UseCVMRole.replace('-', '_'
                    )] or os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN)):
                    raise ConfigurationError('%s is invalid' % param)
            elif param in [OptionsDefine.Region, OptionsDefine.Output,
                OptionsDefine.Language]:
                if param in conf[OptionsDefine.SysParam]:
                    g_param[param] = conf[OptionsDefine.SysParam][param]
                elif param != OptionsDefine.Language:
                    raise ConfigurationError('%s is invalid' % param)
            elif param.replace('_', '-') in [OptionsDefine.RoleArn,
                OptionsDefine.RoleSessionName]:
                if param.replace('_', '-') in cred:
                    g_param[param] = cred[param.replace('_', '-')]
    try:
        if g_param[OptionsDefine.ServiceVersion]:
            g_param[OptionsDefine.Version] = 'v' + g_param[OptionsDefine.
                ServiceVersion].replace('-', '')
        else:
            version = conf['dayu'][OptionsDefine.Version]
            g_param[OptionsDefine.Version] = 'v' + version.replace('-', '')
        if g_param[OptionsDefine.Endpoint] is None:
            g_param[OptionsDefine.Endpoint] = conf['dayu'][OptionsDefine.
                Endpoint]
    except Exception as err:
        raise ConfigurationError('config file:%s error, %s' % (conf_path,
            str(err)))
    if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
        raise Exception('available versions: %s' % ' '.join(
            AVAILABLE_VERSION_LIST))
    if g_param[OptionsDefine.Waiter]:
        param = eval(g_param[OptionsDefine.Waiter])
        if 'expr' not in param:
            raise Exception('`expr` in `--waiter` must be defined')
        if 'to' not in param:
            raise Exception('`to` in `--waiter` must be defined')
        if 'timeout' not in param:
            if 'waiter' in conf and 'timeout' in conf['waiter']:
                param['timeout'] = conf['waiter']['timeout']
            else:
                param['timeout'] = 180
        if 'interval' not in param:
            if 'waiter' in conf and 'interval' in conf['waiter']:
                param['interval'] = conf['waiter']['interval']
            else:
                param['interval'] = 5
        param['interval'] = min(param['interval'], param['timeout'])
        g_param['OptionsDefine.WaiterInfo'] = param
    if six.PY2:
        for key, value in g_param.items():
            if isinstance(value, six.text_type):
                g_param[key] = value.encode('utf-8')
    return g_param

<mask token>


def doModifyCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeRuleSets(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeRuleSetsRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeRuleSets(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateNewL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNewL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNewL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7CCRule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7CCRuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7CCRule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCPolicySwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCPolicySwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCPolicySwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeDDoSNetTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4Health(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4HealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Health(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSUsedStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSUsedStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSUsedStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePcap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePcapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePcap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyElasticLimit(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyElasticLimitRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyElasticLimit(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIpBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doDescribeSchedulingDomainList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSchedulingDomainListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSchedulingDomainList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResBindDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResBindDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResBindDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNetReturnSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNetReturnSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNetReturnSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeSourceIpSegment(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSourceIpSegmentRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSourceIpSegment(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBasicDeviceThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicDeviceThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicDeviceThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateUnblockIp(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateUnblockIpRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateUnblockIp(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNewL4Rule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewL4RuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewL4Rule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBizHttpStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBizHttpStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBizHttpStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeActionLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeActionLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeActionLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribePackIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePackIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePackIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateBasicDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBasicDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBasicDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7RuleCert(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RuleCertRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RuleCert(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSAIStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAIStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAIStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeResourceList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResourceListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResourceList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateBoundIP(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBoundIPRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBoundIP(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL4KeepTime(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4KeepTimeRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4KeepTime(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL4RulesErrHealth(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4RulesErrHealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4RulesErrHealth(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeTransmitStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeTransmitStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeTransmitStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeUnBlockStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeUnBlockStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeUnBlockStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateNetReturn(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNetReturnRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNetReturn(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackSource(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackSourceRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackSource(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyDDoSWaterKey(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSWaterKeyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSWaterKey(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeInsurePacks(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeInsurePacksRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeInsurePacks(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDeleteL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def doModifyCCHostProtection(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCHostProtectionRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCHostProtection(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleRegionCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleRegionCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleRegionCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIpUnBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpUnBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpUnBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeIPProductInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIPProductInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIPProductInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRulesStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRulesStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribleL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyNewDomainRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewDomainRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewDomainRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeCCTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBasicCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeResIpList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResIpListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResIpList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doCreateInstanceName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateInstanceNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateInstanceName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeBGPIPL7RuleMaxCnt(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBGPIPL7RuleMaxCntRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBGPIPL7RuleMaxCnt(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyResourceRenewFlag(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResourceRenewFlagRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResourceRenewFlag(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doModifyCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackIPRegionMap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)
    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[
        OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(g_param[OptionsDefine.
            SecretId], g_param[OptionsDefine.SecretKey], g_param[
            OptionsDefine.RoleArn.replace('-', '_')], g_param[OptionsDefine
            .RoleSessionName.replace('-', '_')])
    elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine
        .ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.
        ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.
        ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(g_param[OptionsDefine.SecretId],
            g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token])
    http_profile = HttpProfile(reqTimeout=60 if g_param[OptionsDefine.
        Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod='POST', endpoint=g_param[OptionsDefine.Endpoint], proxy=
        g_param[OptionsDefine.HttpsProxy.replace('-', '_')])
    profile = ClientProfile(httpProfile=http_profile, signMethod='HmacSHA256')
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += '_CLI_' + __version__
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackIPRegionMapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackIPRegionMap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))
        if not g_param[OptionsDefine.Waiter] or search(g_param[
            'OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param[
            'OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo'][
            'timeout']:
            raise ClientError(
                'Request timeout, wait `%s` to `%s` timeout, last request is %s'
                 % (g_param['OptionsDefine.WaiterInfo']['expr'], g_param[
                'OptionsDefine.WaiterInfo']['to'], search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param[
                'OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output('action', json_obj, g_param[OptionsDefine.Output],
        g_param[OptionsDefine.Filter])


<mask token>


def action_caller():
    return ACTION_MAP


def parse_global_arg(parsed_globals):
    g_param = parsed_globals
    is_exist_profile = True
    if not parsed_globals['profile']:
        is_exist_profile = False
        g_param['profile'] = os.environ.get('TCCLI_PROFILE', 'default')
    configure_path = os.path.join(os.path.expanduser('~'), '.tccli')
    is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.configure')
    is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param[
        'profile'] + '.credential')
    conf = {}
    cred = {}
    if is_conf_exist:
        conf = Utils.load_json_msg(conf_path)
    if is_cred_exist:
        cred = Utils.load_json_msg(cred_path)
    if not (isinstance(conf, dict) and isinstance(cred, dict)):
        raise ConfigurationError('file: %s or %s is not json format' % (
            g_param['profile'] + '.configure', g_param['profile'] +
            '.credential'))
    if OptionsDefine.Token not in cred:
        cred[OptionsDefine.Token] = None
    if not is_exist_profile:
        if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(
            OptionsDefine.ENV_SECRET_KEY):
            cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.
                ENV_SECRET_ID)
            cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.
                ENV_SECRET_KEY)
            cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)
        if os.environ.get(OptionsDefine.ENV_REGION):
            conf[OptionsDefine.SysParam][OptionsDefine.Region
                ] = os.environ.get(OptionsDefine.ENV_REGION)
        if os.environ.get(OptionsDefine.ENV_ROLE_ARN) and os.environ.get(
            OptionsDefine.ENV_ROLE_SESSION_NAME):
            cred[OptionsDefine.RoleArn] = os.environ.get(OptionsDefine.
                ENV_ROLE_ARN)
            cred[OptionsDefine.RoleSessionName] = os.environ.get(OptionsDefine
                .ENV_ROLE_SESSION_NAME)
    for param in g_param.keys():
        if g_param[param] is None:
            if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId,
                OptionsDefine.Token]:
                if param in cred:
                    g_param[param] = cred[param]
                elif not (g_param[OptionsDefine.UseCVMRole.replace('-', '_'
                    )] or os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN)):
                    raise ConfigurationError('%s is invalid' % param)
            elif param in [OptionsDefine.Region, OptionsDefine.Output,
                OptionsDefine.Language]:
                if param in conf[OptionsDefine.SysParam]:
                    g_param[param] = conf[OptionsDefine.SysParam][param]
                elif param != OptionsDefine.Language:
                    raise ConfigurationError('%s is invalid' % param)
            elif param.replace('_', '-') in [OptionsDefine.RoleArn,
                OptionsDefine.RoleSessionName]:
                if param.replace('_', '-') in cred:
                    g_param[param] = cred[param.replace('_', '-')]
    try:
        if g_param[OptionsDefine.ServiceVersion]:
            g_param[OptionsDefine.Version] = 'v' + g_param[OptionsDefine.
                ServiceVersion].replace('-', '')
        else:
            version = conf['dayu'][OptionsDefine.Version]
            g_param[OptionsDefine.Version] = 'v' + version.replace('-', '')
        if g_param[OptionsDefine.Endpoint] is None:
            g_param[OptionsDefine.Endpoint] = conf['dayu'][OptionsDefine.
                Endpoint]
    except Exception as err:
        raise ConfigurationError('config file:%s error, %s' % (conf_path,
            str(err)))
    if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
        raise Exception('available versions: %s' % ' '.join(
            AVAILABLE_VERSION_LIST))
    if g_param[OptionsDefine.Waiter]:
        param = eval(g_param[OptionsDefine.Waiter])
        if 'expr' not in param:
            raise Exception('`expr` in `--waiter` must be defined')
        if 'to' not in param:
            raise Exception('`to` in `--waiter` must be defined')
        if 'timeout' not in param:
            if 'waiter' in conf and 'timeout' in conf['waiter']:
                param['timeout'] = conf['waiter']['timeout']
            else:
                param['timeout'] = 180
        if 'interval' not in param:
            if 'waiter' in conf and 'interval' in conf['waiter']:
                param['interval'] = conf['waiter']['interval']
            else:
                param['interval'] = 5
        param['interval'] = min(param['interval'], param['timeout'])
        g_param['OptionsDefine.WaiterInfo'] = param
    if six.PY2:
        for key, value in g_param.items():
            if isinstance(value, six.text_type):
                g_param[key] = value.encode('utf-8')
    return g_param

# -*- coding: utf-8 -*-
import os
import sys
import six
import json
import tccli.options_define as OptionsDefine
import tccli.format_output as FormatOutput
from tccli import __version__
from tccli.utils import Utils
from tccli.exceptions import ConfigurationError, ClientError, ParamError
from tencentcloud.common import credential
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.dayu.v20180709 import dayu_client as dayu_client_v20180709
from tencentcloud.dayu.v20180709 import models as models_v20180709

from jmespath import search
import time

def doModifyCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeRuleSets(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeRuleSetsRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeRuleSets(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateNewL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNewL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNewL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7CCRule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7CCRuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7CCRule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribleL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCPolicySwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCPolicySwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCPolicySwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL4Health(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4HealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Health(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSUsedStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSUsedStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSUsedStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribePcap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePcapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePcap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyElasticLimit(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyElasticLimitRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyElasticLimit(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeIpBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeSecIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSecIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSecIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeSchedulingDomainList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSchedulingDomainListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSchedulingDomainList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBaradData(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBaradDataRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBaradData(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyResBindDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResBindDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResBindDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyNetReturnSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNetReturnSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNetReturnSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeSourceIpSegment(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeSourceIpSegmentRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeSourceIpSegment(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBasicDeviceThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicDeviceThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicDeviceThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateUnblockIp(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateUnblockIpRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateUnblockIp(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyNewL4Rule(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewL4RuleRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewL4Rule(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBizHttpStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBizHttpStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBizHttpStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribePolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeActionLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeActionLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeActionLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSIpLog(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSIpLogRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSIpLog(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribePackIndex(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribePackIndexRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribePackIndex(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateBasicDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBasicDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBasicDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7RuleCert(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RuleCertRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RuleCert(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSAIStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAIStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAIStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCIpAllowDeny(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCIpAllowDenyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCIpAllowDeny(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL4HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL4HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL4HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeResourceList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResourceListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResourceList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateBoundIP(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateBoundIPRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateBoundIP(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSPolicyCase(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSPolicyCaseRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSPolicyCase(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSAlarmThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSAlarmThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSAlarmThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL4KeepTime(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL4KeepTimeRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL4KeepTime(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeL4RulesErrHealth(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL4RulesErrHealthRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL4RulesErrHealth(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7RulesUpload(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesUploadRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7RulesUpload(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSPolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSPolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSPolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeTransmitStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeTransmitStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeTransmitStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSDefendStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSDefendStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSDefendStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeUnBlockStatis(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeUnBlockStatisRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeUnBlockStatis(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateNetReturn(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateNetReturnRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateNetReturn(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSSwitch(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSSwitchRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSSwitch(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSLevel(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSLevelRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSLevel(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackSource(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackSourceRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackSource(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyDDoSWaterKey(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyDDoSWaterKeyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyDDoSWaterKey(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeInsurePacks(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeInsurePacksRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeInsurePacks(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDeleteL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DeleteL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DeleteL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSNetEvList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSNetEvListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSNetEvList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCHostProtection(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCHostProtectionRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCHostProtection(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribleRegionCount(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleRegionCountRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleRegionCount(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeIpUnBlockList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIpUnBlockListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIpUnBlockList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeIPProductInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeIPProductInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeIPProductInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCFrequencyRulesStatus(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCFrequencyRulesStatusRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCFrequencyRulesStatus(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribleL4Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribleL4RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribleL4Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyNewDomainRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyNewDomainRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyNewDomainRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCUrlAllow(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCUrlAllowRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCUrlAllow(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeCCTrend(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeCCTrendRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeCCTrend(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateCCFrequencyRules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateCCFrequencyRulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateCCFrequencyRules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyL7Rules(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyL7RulesRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyL7Rules(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBasicCCThreshold(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBasicCCThresholdRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBasicCCThreshold(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateL7HealthConfig(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateL7HealthConfigRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateL7HealthConfig(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeResIpList(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeResIpListRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeResIpList(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doCreateInstanceName(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.CreateInstanceNameRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.CreateInstanceName(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeBGPIPL7RuleMaxCnt(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeBGPIPL7RuleMaxCntRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeBGPIPL7RuleMaxCnt(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyResourceRenewFlag(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyResourceRenewFlagRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyResourceRenewFlag(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doModifyCCSelfDefinePolicy(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.ModifyCCSelfDefinePolicyRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.ModifyCCSelfDefinePolicy(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSEvInfo(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSEvInfoRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSEvInfo(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


def doDescribeDDoSAttackIPRegionMap(args, parsed_globals):
    g_param = parse_global_arg(parsed_globals)

    if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
        cred = credential.CVMRoleCredential()
    elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
        cred = credential.STSAssumeRoleCredential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
            g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
        )
    elif os.getenv(OptionsDefine.ENV_TKE_REGION)             and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID)             and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE)             and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
        cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
    else:
        cred = credential.Credential(
            g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
        )
    http_profile = HttpProfile(
        reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
        reqMethod="POST",
        endpoint=g_param[OptionsDefine.Endpoint],
        proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
    )
    profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
    if g_param[OptionsDefine.Language]:
        profile.language = g_param[OptionsDefine.Language]
    mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
    client = mod.DayuClient(cred, g_param[OptionsDefine.Region], profile)
    client._sdkVersion += ("_CLI_" + __version__)
    models = MODELS_MAP[g_param[OptionsDefine.Version]]
    model = models.DescribeDDoSAttackIPRegionMapRequest()
    model.from_json_string(json.dumps(args))
    start_time = time.time()
    while True:
        rsp = client.DescribeDDoSAttackIPRegionMap(model)
        result = rsp.to_json_string()
        try:
            json_obj = json.loads(result)
        except TypeError as e:
            json_obj = json.loads(result.decode('utf-8'))  # python3.3
        if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
            break
        cur_time = time.time()
        if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
            raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
            (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
            search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
        else:
            print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
        time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
    FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])


CLIENT_MAP = {
    "v20180709": dayu_client_v20180709,

}

MODELS_MAP = {
    "v20180709": models_v20180709,

}

ACTION_MAP = {
    "ModifyCCIpAllowDeny": doModifyCCIpAllowDeny,
    "DescribeDDoSCount": doDescribeDDoSCount,
    "DescribeRuleSets": doDescribeRuleSets,
    "CreateNewL7RulesUpload": doCreateNewL7RulesUpload,
    "CreateL7CCRule": doCreateL7CCRule,
    "CreateCCSelfDefinePolicy": doCreateCCSelfDefinePolicy,
    "DescribleL7Rules": doDescribleL7Rules,
    "ModifyCCPolicySwitch": doModifyCCPolicySwitch,
    "CreateDDoSPolicyCase": doCreateDDoSPolicyCase,
    "DescribeDDoSNetTrend": doDescribeDDoSNetTrend,
    "ModifyDDoSPolicyName": doModifyDDoSPolicyName,
    "ModifyL4Health": doModifyL4Health,
    "DescribeDDoSUsedStatis": doDescribeDDoSUsedStatis,
    "DescribeDDoSDefendStatus": doDescribeDDoSDefendStatus,
    "DescribeCCAlarmThreshold": doDescribeCCAlarmThreshold,
    "DescribePcap": doDescribePcap,
    "ModifyElasticLimit": doModifyElasticLimit,
    "DescribeDDoSNetIpLog": doDescribeDDoSNetIpLog,
    "ModifyCCAlarmThreshold": doModifyCCAlarmThreshold,
    "DescribeDDoSEvList": doDescribeDDoSEvList,
    "DescribeIpBlockList": doDescribeIpBlockList,
    "DescribeL4HealthConfig": doDescribeL4HealthConfig,
    "DescribeSecIndex": doDescribeSecIndex,
    "DescribeSchedulingDomainList": doDescribeSchedulingDomainList,
    "DescribeCCFrequencyRules": doDescribeCCFrequencyRules,
    "DeleteDDoSPolicyCase": doDeleteDDoSPolicyCase,
    "DeleteL7Rules": doDeleteL7Rules,
    "CreateL4Rules": doCreateL4Rules,
    "DescribeBaradData": doDescribeBaradData,
    "ModifyCCFrequencyRules": doModifyCCFrequencyRules,
    "CreateDDoSPolicy": doCreateDDoSPolicy,
    "ModifyResBindDDoSPolicy": doModifyResBindDDoSPolicy,
    "ModifyNetReturnSwitch": doModifyNetReturnSwitch,
    "DescribeSourceIpSegment": doDescribeSourceIpSegment,
    "ModifyCCUrlAllow": doModifyCCUrlAllow,
    "DescribeBasicDeviceThreshold": doDescribeBasicDeviceThreshold,
    "CreateUnblockIp": doCreateUnblockIp,
    "ModifyNewL4Rule": doModifyNewL4Rule,
    "DeleteDDoSPolicy": doDeleteDDoSPolicy,
    "DescribeDDoSNetCount": doDescribeDDoSNetCount,
    "DescribeBizHttpStatus": doDescribeBizHttpStatus,
    "DeleteCCSelfDefinePolicy": doDeleteCCSelfDefinePolicy,
    "DescribePolicyCase": doDescribePolicyCase,
    "DescribeActionLog": doDescribeActionLog,
    "ModifyL4Rules": doModifyL4Rules,
    "DescribeDDoSIpLog": doDescribeDDoSIpLog,
    "DescribeDDoSAlarmThreshold": doDescribeDDoSAlarmThreshold,
    "DescribePackIndex": doDescribePackIndex,
    "CreateBasicDDoSAlarmThreshold": doCreateBasicDDoSAlarmThreshold,
    "ModifyDDoSThreshold": doModifyDDoSThreshold,
    "CreateL7RuleCert": doCreateL7RuleCert,
    "ModifyDDoSAIStatus": doModifyDDoSAIStatus,
    "DescribeCCIpAllowDeny": doDescribeCCIpAllowDeny,
    "CreateL4HealthConfig": doCreateL4HealthConfig,
    "DescribeResourceList": doDescribeResourceList,
    "CreateBoundIP": doCreateBoundIP,
    "ModifyDDoSPolicy": doModifyDDoSPolicy,
    "ModifyDDoSPolicyCase": doModifyDDoSPolicyCase,
    "ModifyDDoSAlarmThreshold": doModifyDDoSAlarmThreshold,
    "DescribeDDoSNetEvInfo": doDescribeDDoSNetEvInfo,
    "DeleteCCFrequencyRules": doDeleteCCFrequencyRules,
    "ModifyL4KeepTime": doModifyL4KeepTime,
    "DescribeL4RulesErrHealth": doDescribeL4RulesErrHealth,
    "CreateL7RulesUpload": doCreateL7RulesUpload,
    "DescribeDDoSPolicy": doDescribeDDoSPolicy,
    "DescribeTransmitStatis": doDescribeTransmitStatis,
    "ModifyCCLevel": doModifyCCLevel,
    "ModifyDDoSDefendStatus": doModifyDDoSDefendStatus,
    "DescribeUnBlockStatis": doDescribeUnBlockStatis,
    "DescribeDDoSTrend": doDescribeDDoSTrend,
    "CreateNetReturn": doCreateNetReturn,
    "ModifyDDoSSwitch": doModifyDDoSSwitch,
    "ModifyDDoSLevel": doModifyDDoSLevel,
    "DescribeDDoSAttackSource": doDescribeDDoSAttackSource,
    "DescribeCCEvList": doDescribeCCEvList,
    "ModifyDDoSWaterKey": doModifyDDoSWaterKey,
    "DescribeInsurePacks": doDescribeInsurePacks,
    "DeleteL4Rules": doDeleteL4Rules,
    "DescribeDDoSNetEvList": doDescribeDDoSNetEvList,
    "ModifyCCHostProtection": doModifyCCHostProtection,
    "DescribleRegionCount": doDescribleRegionCount,
    "CreateL7Rules": doCreateL7Rules,
    "DescribeIpUnBlockList": doDescribeIpUnBlockList,
    "DescribeIPProductInfo": doDescribeIPProductInfo,
    "DescribeCCSelfDefinePolicy": doDescribeCCSelfDefinePolicy,
    "ModifyCCFrequencyRulesStatus": doModifyCCFrequencyRulesStatus,
    "ModifyCCThreshold": doModifyCCThreshold,
    "DescribleL4Rules": doDescribleL4Rules,
    "ModifyNewDomainRules": doModifyNewDomainRules,
    "DescribeCCUrlAllow": doDescribeCCUrlAllow,
    "DescribeL7HealthConfig": doDescribeL7HealthConfig,
    "DescribeCCTrend": doDescribeCCTrend,
    "CreateCCFrequencyRules": doCreateCCFrequencyRules,
    "ModifyL7Rules": doModifyL7Rules,
    "DescribeBasicCCThreshold": doDescribeBasicCCThreshold,
    "CreateL7HealthConfig": doCreateL7HealthConfig,
    "DescribeResIpList": doDescribeResIpList,
    "CreateInstanceName": doCreateInstanceName,
    "DescribeBGPIPL7RuleMaxCnt": doDescribeBGPIPL7RuleMaxCnt,
    "ModifyResourceRenewFlag": doModifyResourceRenewFlag,
    "ModifyCCSelfDefinePolicy": doModifyCCSelfDefinePolicy,
    "DescribeDDoSEvInfo": doDescribeDDoSEvInfo,
    "DescribeDDoSAttackIPRegionMap": doDescribeDDoSAttackIPRegionMap,

}

AVAILABLE_VERSION_LIST = [
    "v20180709",

]


def action_caller():
    return ACTION_MAP


def parse_global_arg(parsed_globals):
    g_param = parsed_globals

    is_exist_profile = True
    if not parsed_globals["profile"]:
        is_exist_profile = False
        g_param["profile"] = os.environ.get("TCCLI_PROFILE", "default")

    configure_path = os.path.join(os.path.expanduser("~"), ".tccli")
    is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param["profile"] + ".configure")
    is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param["profile"] + ".credential")

    conf = {}
    cred = {}

    if is_conf_exist:
        conf = Utils.load_json_msg(conf_path)
    if is_cred_exist:
        cred = Utils.load_json_msg(cred_path)

    if not (isinstance(conf, dict) and isinstance(cred, dict)):
        raise ConfigurationError(
            "file: %s or %s is not json format"
            % (g_param["profile"] + ".configure", g_param["profile"] + ".credential"))

    if OptionsDefine.Token not in cred:
        cred[OptionsDefine.Token] = None

    if not is_exist_profile:
        if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(OptionsDefine.ENV_SECRET_KEY):
            cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.ENV_SECRET_ID)
            cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.ENV_SECRET_KEY)
            cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)

        if os.environ.get(OptionsDefine.ENV_REGION):
            conf[OptionsDefine.SysParam][OptionsDefine.Region] = os.environ.get(OptionsDefine.ENV_REGION)

        if os.environ.get(OptionsDefine.ENV_ROLE_ARN) and os.environ.get(OptionsDefine.ENV_ROLE_SESSION_NAME):
            cred[OptionsDefine.RoleArn] = os.environ.get(OptionsDefine.ENV_ROLE_ARN)
            cred[OptionsDefine.RoleSessionName] = os.environ.get(OptionsDefine.ENV_ROLE_SESSION_NAME)

    for param in g_param.keys():
        if g_param[param] is None:
            if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId, OptionsDefine.Token]:
                if param in cred:
                    g_param[param] = cred[param]
                elif not (g_param[OptionsDefine.UseCVMRole.replace('-', '_')]
                          or os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN)):
                    raise ConfigurationError("%s is invalid" % param)
            elif param in [OptionsDefine.Region, OptionsDefine.Output, OptionsDefine.Language]:
                if param in conf[OptionsDefine.SysParam]:
                    g_param[param] = conf[OptionsDefine.SysParam][param]
                elif param != OptionsDefine.Language:
                    raise ConfigurationError("%s is invalid" % param)
            elif param.replace('_', '-') in [OptionsDefine.RoleArn, OptionsDefine.RoleSessionName]:
                if param.replace('_', '-') in cred:
                    g_param[param] = cred[param.replace('_', '-')]

    try:
        if g_param[OptionsDefine.ServiceVersion]:
            g_param[OptionsDefine.Version] = "v" + g_param[OptionsDefine.ServiceVersion].replace('-', '')
        else:
            version = conf["dayu"][OptionsDefine.Version]
            g_param[OptionsDefine.Version] = "v" + version.replace('-', '')

        if g_param[OptionsDefine.Endpoint] is None:
            g_param[OptionsDefine.Endpoint] = conf["dayu"][OptionsDefine.Endpoint]
    except Exception as err:
        raise ConfigurationError("config file:%s error, %s" % (conf_path, str(err)))

    if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
        raise Exception("available versions: %s" % " ".join(AVAILABLE_VERSION_LIST))

    if g_param[OptionsDefine.Waiter]:
        param = eval(g_param[OptionsDefine.Waiter])
        if 'expr' not in param:
            raise Exception('`expr` in `--waiter` must be defined')
        if 'to' not in param:
            raise Exception('`to` in `--waiter` must be defined')
        if 'timeout' not in param:
            if 'waiter' in conf and 'timeout' in conf['waiter']:
                param['timeout'] = conf['waiter']['timeout']
            else:
                param['timeout'] = 180
        if 'interval' not in param:
            if 'waiter' in conf and 'interval' in conf['waiter']:
                param['interval'] = conf['waiter']['interval']
            else:
                param['interval'] = 5
        param['interval'] = min(param['interval'], param['timeout'])
        g_param['OptionsDefine.WaiterInfo'] = param

    if six.PY2:
        for key, value in g_param.items():
            if isinstance(value, six.text_type):
                g_param[key] = value.encode('utf-8')
    return g_param

