text: # -*- 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.dcdb.v20180411 import dcdb_client as dcdb_client_v20180411
  from tencentcloud.dcdb.v20180411 import models as models_v20180411
  
  from jmespath import search
  import time
  
  def doDescribeAccountPrivileges(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAccountPrivilegesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeAccountPrivileges(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 doDescribeOrders(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeOrdersRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeOrders(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 doDescribeDatabaseObjects(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDatabaseObjectsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDatabaseObjects(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 doDescribeShardSpec(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeShardSpecRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeShardSpec(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 doDescribeDCDBUpgradePrice(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBUpgradePriceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBUpgradePrice(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 doDescribeDCDBInstances(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBInstancesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBInstances(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 doModifyRealServerAccessStrategy(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyRealServerAccessStrategyRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ModifyRealServerAccessStrategy(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 doActiveHourDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ActiveHourDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ActiveHourDCDBInstance(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 doDescribeFileDownloadUrl(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeFileDownloadUrlRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeFileDownloadUrl(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 doResetAccountPassword(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ResetAccountPasswordRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ResetAccountPassword(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 doDescribeUserTasks(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeUserTasksRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeUserTasks(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 doModifyDBParameters(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyDBParametersRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ModifyDBParameters(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 doDescribeDCDBSaleInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBSaleInfoRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBSaleInfo(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 doDescribeDBSlowLogs(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDBSlowLogsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDBSlowLogs(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 doDescribeFlow(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeFlowRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeFlow(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 doSwitchDBInstanceHA(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.SwitchDBInstanceHARequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.SwitchDBInstanceHA(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 doCloneAccount(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CloneAccountRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CloneAccount(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 doDescribeAccounts(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAccountsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeAccounts(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 doCreateDedicatedClusterDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateDedicatedClusterDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CreateDedicatedClusterDCDBInstance(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 doRenewDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.RenewDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.RenewDCDBInstance(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 doDeleteAccount(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteAccountRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DeleteAccount(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 doDescribeDBParameters(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDBParametersRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDBParameters(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 doModifyDBInstancesProject(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyDBInstancesProjectRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ModifyDBInstancesProject(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 doDescribeSqlLogs(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSqlLogsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeSqlLogs(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 doDescribeDBLogFiles(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDBLogFilesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDBLogFiles(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 doIsolateHourDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.IsolateHourDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.IsolateHourDCDBInstance(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 doDescribeDBSyncMode(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDBSyncModeRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDBSyncMode(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 doDescribeProjectSecurityGroups(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeProjectSecurityGroupsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeProjectSecurityGroups(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 doAssociateSecurityGroups(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.AssociateSecurityGroupsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.AssociateSecurityGroups(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 doDescribeDCDBPrice(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBPriceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBPrice(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 doKillSession(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.KillSessionRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.KillSession(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 doOpenDBExtranetAccess(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.OpenDBExtranetAccessRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.OpenDBExtranetAccess(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 doDestroyDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DestroyDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DestroyDCDBInstance(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 doDescribeDCDBInstanceNodeInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBInstanceNodeInfoRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBInstanceNodeInfo(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 doModifyDBSyncMode(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyDBSyncModeRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ModifyDBSyncMode(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 doDescribeProjects(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeProjectsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeProjects(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 doCloseDBExtranetAccess(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CloseDBExtranetAccessRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CloseDBExtranetAccess(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 doModifyAccountDescription(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyAccountDescriptionRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ModifyAccountDescription(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 doDescribeDcnDetail(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDcnDetailRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDcnDetail(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 doDisassociateSecurityGroups(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DisassociateSecurityGroupsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DisassociateSecurityGroups(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 doGrantAccountPrivileges(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.GrantAccountPrivilegesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.GrantAccountPrivileges(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 doCopyAccountPrivileges(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CopyAccountPrivilegesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CopyAccountPrivileges(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 doDescribeDCDBShards(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBShardsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBShards(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 doCreateDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CreateDCDBInstance(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 doDescribeDatabases(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDatabasesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDatabases(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 doDestroyHourDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DestroyHourDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DestroyHourDCDBInstance(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 doDescribeDBSecurityGroups(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDBSecurityGroupsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDBSecurityGroups(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 doDescribeDatabaseTable(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDatabaseTableRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDatabaseTable(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 doCancelDcnJob(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CancelDcnJobRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CancelDcnJob(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 doInitDCDBInstances(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.InitDCDBInstancesRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.InitDCDBInstances(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 doCreateAccount(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateAccountRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CreateAccount(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 doCreateHourDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateHourDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.CreateHourDCDBInstance(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 doFlushBinlog(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.FlushBinlogRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.FlushBinlog(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 doUpgradeDCDBInstance(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.UpgradeDCDBInstanceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.UpgradeDCDBInstance(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 doDescribeDCDBRenewalPrice(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeDCDBRenewalPriceRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.DescribeDCDBRenewalPrice(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 doModifyDBInstanceSecurityGroups(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
          cred = credential.CVMRoleCredential()
      elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
          cred = credential.STSAssumeRoleCredential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
              g_param[OptionsDefine.RoleSessionName.replace('-', '_')]
          )
      else:
          cred = credential.Credential(
              g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
          )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint],
          proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.DcdbClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyDBInstanceSecurityGroupsRequest()
      model.from_json_string(json.dumps(args))
      start_time = time.time()
      while True:
          rsp = client.ModifyDBInstanceSecurityGroups(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 = {
      "v20180411": dcdb_client_v20180411,
  
  }
  
  MODELS_MAP = {
      "v20180411": models_v20180411,
  
  }
  
  ACTION_MAP = {
      "DescribeAccountPrivileges": doDescribeAccountPrivileges,
      "DescribeOrders": doDescribeOrders,
      "DescribeDatabaseObjects": doDescribeDatabaseObjects,
      "DescribeShardSpec": doDescribeShardSpec,
      "DescribeDCDBUpgradePrice": doDescribeDCDBUpgradePrice,
      "DescribeDCDBInstances": doDescribeDCDBInstances,
      "ModifyRealServerAccessStrategy": doModifyRealServerAccessStrategy,
      "ActiveHourDCDBInstance": doActiveHourDCDBInstance,
      "DescribeFileDownloadUrl": doDescribeFileDownloadUrl,
      "ResetAccountPassword": doResetAccountPassword,
      "DescribeUserTasks": doDescribeUserTasks,
      "ModifyDBParameters": doModifyDBParameters,
      "DescribeDCDBSaleInfo": doDescribeDCDBSaleInfo,
      "DescribeDBSlowLogs": doDescribeDBSlowLogs,
      "DescribeFlow": doDescribeFlow,
      "SwitchDBInstanceHA": doSwitchDBInstanceHA,
      "CloneAccount": doCloneAccount,
      "DescribeAccounts": doDescribeAccounts,
      "CreateDedicatedClusterDCDBInstance": doCreateDedicatedClusterDCDBInstance,
      "RenewDCDBInstance": doRenewDCDBInstance,
      "DeleteAccount": doDeleteAccount,
      "DescribeDBParameters": doDescribeDBParameters,
      "ModifyDBInstancesProject": doModifyDBInstancesProject,
      "DescribeSqlLogs": doDescribeSqlLogs,
      "DescribeDBLogFiles": doDescribeDBLogFiles,
      "IsolateHourDCDBInstance": doIsolateHourDCDBInstance,
      "DescribeDBSyncMode": doDescribeDBSyncMode,
      "DescribeProjectSecurityGroups": doDescribeProjectSecurityGroups,
      "AssociateSecurityGroups": doAssociateSecurityGroups,
      "DescribeDCDBPrice": doDescribeDCDBPrice,
      "KillSession": doKillSession,
      "OpenDBExtranetAccess": doOpenDBExtranetAccess,
      "DestroyDCDBInstance": doDestroyDCDBInstance,
      "DescribeDCDBInstanceNodeInfo": doDescribeDCDBInstanceNodeInfo,
      "ModifyDBSyncMode": doModifyDBSyncMode,
      "DescribeProjects": doDescribeProjects,
      "CloseDBExtranetAccess": doCloseDBExtranetAccess,
      "ModifyAccountDescription": doModifyAccountDescription,
      "DescribeDcnDetail": doDescribeDcnDetail,
      "DisassociateSecurityGroups": doDisassociateSecurityGroups,
      "GrantAccountPrivileges": doGrantAccountPrivileges,
      "CopyAccountPrivileges": doCopyAccountPrivileges,
      "DescribeDCDBShards": doDescribeDCDBShards,
      "CreateDCDBInstance": doCreateDCDBInstance,
      "DescribeDatabases": doDescribeDatabases,
      "DestroyHourDCDBInstance": doDestroyHourDCDBInstance,
      "DescribeDBSecurityGroups": doDescribeDBSecurityGroups,
      "DescribeDatabaseTable": doDescribeDatabaseTable,
      "CancelDcnJob": doCancelDcnJob,
      "InitDCDBInstances": doInitDCDBInstances,
      "CreateAccount": doCreateAccount,
      "CreateHourDCDBInstance": doCreateHourDCDBInstance,
      "FlushBinlog": doFlushBinlog,
      "UpgradeDCDBInstance": doUpgradeDCDBInstance,
      "DescribeDCDBRenewalPrice": doDescribeDCDBRenewalPrice,
      "ModifyDBInstanceSecurityGroups": doModifyDBInstanceSecurityGroups,
  
  }
  
  AVAILABLE_VERSION_LIST = [
      "v20180411",
  
  ]
  
  
  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"] = "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.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('-', '_')]:
                      raise ConfigurationError("%s is invalid" % param)
              elif param in [OptionsDefine.Region, OptionsDefine.Output]:
                  if param in conf:
                      g_param[param] = conf[param]
                  else:
                      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["dcdb"][OptionsDefine.Version]
              g_param[OptionsDefine.Version] = "v" + version.replace('-', '')
  
          if g_param[OptionsDefine.Endpoint] is None:
              g_param[OptionsDefine.Endpoint] = conf["dcdb"][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['timeout'] = 5
          param['interval'] = min(param['interval'], param['timeout'])
          g_param['OptionsDefine.WaiterInfo'] = param
      
      # 如果在配置文件中读取字段的值，python2中的json.load函数会读取unicode类型的值，因此这里要转化类型
      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
  
  