tccli-intl-en 3.1.1.1__py2.py3-none-any.whl → 3.1.11.1__py2.py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (49) hide show
  1. tccli/__init__.py +1 -1
  2. tccli/services/__init__.py +6 -0
  3. tccli/services/autoscaling/v20180419/api.json +36 -14
  4. tccli/services/ckafka/ckafka_client.py +288 -8
  5. tccli/services/ckafka/v20190819/api.json +494 -76
  6. tccli/services/ckafka/v20190819/examples.json +45 -5
  7. tccli/services/clb/clb_client.py +636 -300
  8. tccli/services/clb/v20180317/api.json +1245 -367
  9. tccli/services/clb/v20180317/examples.json +172 -112
  10. tccli/services/controlcenter/controlcenter_client.py +224 -0
  11. tccli/services/controlcenter/v20230110/api.json +528 -5
  12. tccli/services/controlcenter/v20230110/examples.json +32 -0
  13. tccli/services/cvm/v20170312/examples.json +1 -1
  14. tccli/services/faceid/v20180301/api.json +31 -3
  15. tccli/services/kms/v20190118/api.json +80 -3
  16. tccli/services/kms/v20190118/examples.json +3 -3
  17. tccli/services/mdl/v20200326/api.json +165 -5
  18. tccli/services/mongodb/mongodb_client.py +1048 -96
  19. tccli/services/mongodb/v20190725/api.json +1765 -108
  20. tccli/services/mongodb/v20190725/examples.json +136 -0
  21. tccli/services/monitor/v20180724/api.json +3 -3
  22. tccli/services/mps/mps_client.py +713 -209
  23. tccli/services/mps/v20190612/api.json +1009 -67
  24. tccli/services/mps/v20190612/examples.json +100 -52
  25. tccli/services/ocr/ocr_client.py +112 -0
  26. tccli/services/ocr/v20181119/api.json +514 -0
  27. tccli/services/ocr/v20181119/examples.json +22 -0
  28. tccli/services/smh/__init__.py +4 -0
  29. tccli/services/smh/smh_client.py +714 -0
  30. tccli/services/smh/v20210712/api.json +1287 -0
  31. tccli/services/smh/v20210712/examples.json +85 -0
  32. tccli/services/tdmq/tdmq_client.py +2406 -278
  33. tccli/services/tdmq/v20200217/api.json +11607 -3958
  34. tccli/services/tdmq/v20200217/examples.json +562 -264
  35. tccli/services/teo/teo_client.py +169 -57
  36. tccli/services/teo/v20220901/api.json +218 -9
  37. tccli/services/teo/v20220901/examples.json +56 -22
  38. tccli/services/trocket/__init__.py +4 -0
  39. tccli/services/trocket/trocket_client.py +2450 -0
  40. tccli/services/trocket/v20230308/api.json +6062 -0
  41. tccli/services/trocket/v20230308/examples.json +339 -0
  42. tccli/services/vpc/v20170312/api.json +19 -16
  43. tccli/services/vpc/v20170312/examples.json +4 -4
  44. {tccli_intl_en-3.1.1.1.dist-info → tccli_intl_en-3.1.11.1.dist-info}/METADATA +2 -2
  45. {tccli_intl_en-3.1.1.1.dist-info → tccli_intl_en-3.1.11.1.dist-info}/RECORD +49 -41
  46. {tccli_intl_en-3.1.1.1.dist-info → tccli_intl_en-3.1.11.1.dist-info}/LICENSE +0 -0
  47. {tccli_intl_en-3.1.1.1.dist-info → tccli_intl_en-3.1.11.1.dist-info}/WHEEL +0 -0
  48. {tccli_intl_en-3.1.1.1.dist-info → tccli_intl_en-3.1.11.1.dist-info}/entry_points.txt +0 -0
  49. {tccli_intl_en-3.1.1.1.dist-info → tccli_intl_en-3.1.11.1.dist-info}/top_level.txt +0 -0
tccli/services/mongodb/mongodb_client.py CHANGED
@@ -72,6 +72,61 @@ def doTerminateDBInstances(args, parsed_globals):
72
72
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
73
73
 
74
74
 
75
+ def doCreateLogDownloadTask(args, parsed_globals):
76
+ g_param = parse_global_arg(parsed_globals)
77
+
78
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
79
+ cred = credential.CVMRoleCredential()
80
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
81
+ cred = credential.STSAssumeRoleCredential(
82
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
83
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
84
+ )
85
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
86
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
87
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
88
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
89
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
90
+ else:
91
+ cred = credential.Credential(
92
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
93
+ )
94
+ http_profile = HttpProfile(
95
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
96
+ reqMethod="POST",
97
+ endpoint=g_param[OptionsDefine.Endpoint],
98
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
99
+ )
100
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
101
+ if g_param[OptionsDefine.Language]:
102
+ profile.language = g_param[OptionsDefine.Language]
103
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
104
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
105
+ client._sdkVersion += ("_CLI_" + __version__)
106
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
107
+ model = models.CreateLogDownloadTaskRequest()
108
+ model.from_json_string(json.dumps(args))
109
+ start_time = time.time()
110
+ while True:
111
+ rsp = client.CreateLogDownloadTask(model)
112
+ result = rsp.to_json_string()
113
+ try:
114
+ json_obj = json.loads(result)
115
+ except TypeError as e:
116
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
117
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
118
+ break
119
+ cur_time = time.time()
120
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
121
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
122
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
123
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
124
+ else:
125
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
126
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
127
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
128
+
129
+
75
130
  def doDescribeDBInstanceNodeProperty(args, parsed_globals):
76
131
  g_param = parse_global_arg(parsed_globals)
77
132
 
@@ -104,11 +159,836 @@ def doDescribeDBInstanceNodeProperty(args, parsed_globals):
104
159
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
105
160
  client._sdkVersion += ("_CLI_" + __version__)
106
161
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
107
- model = models.DescribeDBInstanceNodePropertyRequest()
162
+ model = models.DescribeDBInstanceNodePropertyRequest()
163
+ model.from_json_string(json.dumps(args))
164
+ start_time = time.time()
165
+ while True:
166
+ rsp = client.DescribeDBInstanceNodeProperty(model)
167
+ result = rsp.to_json_string()
168
+ try:
169
+ json_obj = json.loads(result)
170
+ except TypeError as e:
171
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
172
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
173
+ break
174
+ cur_time = time.time()
175
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
176
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
177
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
178
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
179
+ else:
180
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
181
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
182
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
183
+
184
+
185
+ def doDescribeDBInstanceDeal(args, parsed_globals):
186
+ g_param = parse_global_arg(parsed_globals)
187
+
188
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
189
+ cred = credential.CVMRoleCredential()
190
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
191
+ cred = credential.STSAssumeRoleCredential(
192
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
193
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
194
+ )
195
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
196
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
197
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
198
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
199
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
200
+ else:
201
+ cred = credential.Credential(
202
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
203
+ )
204
+ http_profile = HttpProfile(
205
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
206
+ reqMethod="POST",
207
+ endpoint=g_param[OptionsDefine.Endpoint],
208
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
209
+ )
210
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
211
+ if g_param[OptionsDefine.Language]:
212
+ profile.language = g_param[OptionsDefine.Language]
213
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
214
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
215
+ client._sdkVersion += ("_CLI_" + __version__)
216
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
217
+ model = models.DescribeDBInstanceDealRequest()
218
+ model.from_json_string(json.dumps(args))
219
+ start_time = time.time()
220
+ while True:
221
+ rsp = client.DescribeDBInstanceDeal(model)
222
+ result = rsp.to_json_string()
223
+ try:
224
+ json_obj = json.loads(result)
225
+ except TypeError as e:
226
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
227
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
228
+ break
229
+ cur_time = time.time()
230
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
231
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
232
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
233
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
234
+ else:
235
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
236
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
237
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
238
+
239
+
240
+ def doDescribeCurrentOp(args, parsed_globals):
241
+ g_param = parse_global_arg(parsed_globals)
242
+
243
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
244
+ cred = credential.CVMRoleCredential()
245
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
246
+ cred = credential.STSAssumeRoleCredential(
247
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
248
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
249
+ )
250
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
251
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
252
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
253
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
254
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
255
+ else:
256
+ cred = credential.Credential(
257
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
258
+ )
259
+ http_profile = HttpProfile(
260
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
261
+ reqMethod="POST",
262
+ endpoint=g_param[OptionsDefine.Endpoint],
263
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
264
+ )
265
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
266
+ if g_param[OptionsDefine.Language]:
267
+ profile.language = g_param[OptionsDefine.Language]
268
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
269
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
270
+ client._sdkVersion += ("_CLI_" + __version__)
271
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
272
+ model = models.DescribeCurrentOpRequest()
273
+ model.from_json_string(json.dumps(args))
274
+ start_time = time.time()
275
+ while True:
276
+ rsp = client.DescribeCurrentOp(model)
277
+ result = rsp.to_json_string()
278
+ try:
279
+ json_obj = json.loads(result)
280
+ except TypeError as e:
281
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
282
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
283
+ break
284
+ cur_time = time.time()
285
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
286
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
287
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
288
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
289
+ else:
290
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
291
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
292
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
293
+
294
+
295
+ def doDescribeDBBackups(args, parsed_globals):
296
+ g_param = parse_global_arg(parsed_globals)
297
+
298
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
299
+ cred = credential.CVMRoleCredential()
300
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
301
+ cred = credential.STSAssumeRoleCredential(
302
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
303
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
304
+ )
305
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
306
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
307
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
308
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
309
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
310
+ else:
311
+ cred = credential.Credential(
312
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
313
+ )
314
+ http_profile = HttpProfile(
315
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
316
+ reqMethod="POST",
317
+ endpoint=g_param[OptionsDefine.Endpoint],
318
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
319
+ )
320
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
321
+ if g_param[OptionsDefine.Language]:
322
+ profile.language = g_param[OptionsDefine.Language]
323
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
324
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
325
+ client._sdkVersion += ("_CLI_" + __version__)
326
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
327
+ model = models.DescribeDBBackupsRequest()
328
+ model.from_json_string(json.dumps(args))
329
+ start_time = time.time()
330
+ while True:
331
+ rsp = client.DescribeDBBackups(model)
332
+ result = rsp.to_json_string()
333
+ try:
334
+ json_obj = json.loads(result)
335
+ except TypeError as e:
336
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
337
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
338
+ break
339
+ cur_time = time.time()
340
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
341
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
342
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
343
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
344
+ else:
345
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
346
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
347
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
348
+
349
+
350
+ def doDescribeClientConnections(args, parsed_globals):
351
+ g_param = parse_global_arg(parsed_globals)
352
+
353
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
354
+ cred = credential.CVMRoleCredential()
355
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
356
+ cred = credential.STSAssumeRoleCredential(
357
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
358
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
359
+ )
360
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
361
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
362
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
363
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
364
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
365
+ else:
366
+ cred = credential.Credential(
367
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
368
+ )
369
+ http_profile = HttpProfile(
370
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
371
+ reqMethod="POST",
372
+ endpoint=g_param[OptionsDefine.Endpoint],
373
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
374
+ )
375
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
376
+ if g_param[OptionsDefine.Language]:
377
+ profile.language = g_param[OptionsDefine.Language]
378
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
379
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
380
+ client._sdkVersion += ("_CLI_" + __version__)
381
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
382
+ model = models.DescribeClientConnectionsRequest()
383
+ model.from_json_string(json.dumps(args))
384
+ start_time = time.time()
385
+ while True:
386
+ rsp = client.DescribeClientConnections(model)
387
+ result = rsp.to_json_string()
388
+ try:
389
+ json_obj = json.loads(result)
390
+ except TypeError as e:
391
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
392
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
393
+ break
394
+ cur_time = time.time()
395
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
396
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
397
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
398
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
399
+ else:
400
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
401
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
402
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
403
+
404
+
405
+ def doResetDBInstancePassword(args, parsed_globals):
406
+ g_param = parse_global_arg(parsed_globals)
407
+
408
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
409
+ cred = credential.CVMRoleCredential()
410
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
411
+ cred = credential.STSAssumeRoleCredential(
412
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
413
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
414
+ )
415
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
416
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
417
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
418
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
419
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
420
+ else:
421
+ cred = credential.Credential(
422
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
423
+ )
424
+ http_profile = HttpProfile(
425
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
426
+ reqMethod="POST",
427
+ endpoint=g_param[OptionsDefine.Endpoint],
428
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
429
+ )
430
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
431
+ if g_param[OptionsDefine.Language]:
432
+ profile.language = g_param[OptionsDefine.Language]
433
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
434
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
435
+ client._sdkVersion += ("_CLI_" + __version__)
436
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
437
+ model = models.ResetDBInstancePasswordRequest()
438
+ model.from_json_string(json.dumps(args))
439
+ start_time = time.time()
440
+ while True:
441
+ rsp = client.ResetDBInstancePassword(model)
442
+ result = rsp.to_json_string()
443
+ try:
444
+ json_obj = json.loads(result)
445
+ except TypeError as e:
446
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
447
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
448
+ break
449
+ cur_time = time.time()
450
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
451
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
452
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
453
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
454
+ else:
455
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
456
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
457
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
458
+
459
+
460
+ def doDescribeSecurityGroup(args, parsed_globals):
461
+ g_param = parse_global_arg(parsed_globals)
462
+
463
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
464
+ cred = credential.CVMRoleCredential()
465
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
466
+ cred = credential.STSAssumeRoleCredential(
467
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
468
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
469
+ )
470
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
471
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
472
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
473
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
474
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
475
+ else:
476
+ cred = credential.Credential(
477
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
478
+ )
479
+ http_profile = HttpProfile(
480
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
481
+ reqMethod="POST",
482
+ endpoint=g_param[OptionsDefine.Endpoint],
483
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
484
+ )
485
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
486
+ if g_param[OptionsDefine.Language]:
487
+ profile.language = g_param[OptionsDefine.Language]
488
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
489
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
490
+ client._sdkVersion += ("_CLI_" + __version__)
491
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
492
+ model = models.DescribeSecurityGroupRequest()
493
+ model.from_json_string(json.dumps(args))
494
+ start_time = time.time()
495
+ while True:
496
+ rsp = client.DescribeSecurityGroup(model)
497
+ result = rsp.to_json_string()
498
+ try:
499
+ json_obj = json.loads(result)
500
+ except TypeError as e:
501
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
502
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
503
+ break
504
+ cur_time = time.time()
505
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
506
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
507
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
508
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
509
+ else:
510
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
511
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
512
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
513
+
514
+
515
+ def doSetAccountUserPrivilege(args, parsed_globals):
516
+ g_param = parse_global_arg(parsed_globals)
517
+
518
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
519
+ cred = credential.CVMRoleCredential()
520
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
521
+ cred = credential.STSAssumeRoleCredential(
522
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
523
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
524
+ )
525
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
526
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
527
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
528
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
529
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
530
+ else:
531
+ cred = credential.Credential(
532
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
533
+ )
534
+ http_profile = HttpProfile(
535
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
536
+ reqMethod="POST",
537
+ endpoint=g_param[OptionsDefine.Endpoint],
538
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
539
+ )
540
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
541
+ if g_param[OptionsDefine.Language]:
542
+ profile.language = g_param[OptionsDefine.Language]
543
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
544
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
545
+ client._sdkVersion += ("_CLI_" + __version__)
546
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
547
+ model = models.SetAccountUserPrivilegeRequest()
548
+ model.from_json_string(json.dumps(args))
549
+ start_time = time.time()
550
+ while True:
551
+ rsp = client.SetAccountUserPrivilege(model)
552
+ result = rsp.to_json_string()
553
+ try:
554
+ json_obj = json.loads(result)
555
+ except TypeError as e:
556
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
557
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
558
+ break
559
+ cur_time = time.time()
560
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
561
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
562
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
563
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
564
+ else:
565
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
566
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
567
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
568
+
569
+
570
+ def doFlushInstanceRouterConfig(args, parsed_globals):
571
+ g_param = parse_global_arg(parsed_globals)
572
+
573
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
574
+ cred = credential.CVMRoleCredential()
575
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
576
+ cred = credential.STSAssumeRoleCredential(
577
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
578
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
579
+ )
580
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
581
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
582
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
583
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
584
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
585
+ else:
586
+ cred = credential.Credential(
587
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
588
+ )
589
+ http_profile = HttpProfile(
590
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
591
+ reqMethod="POST",
592
+ endpoint=g_param[OptionsDefine.Endpoint],
593
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
594
+ )
595
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
596
+ if g_param[OptionsDefine.Language]:
597
+ profile.language = g_param[OptionsDefine.Language]
598
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
599
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
600
+ client._sdkVersion += ("_CLI_" + __version__)
601
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
602
+ model = models.FlushInstanceRouterConfigRequest()
603
+ model.from_json_string(json.dumps(args))
604
+ start_time = time.time()
605
+ while True:
606
+ rsp = client.FlushInstanceRouterConfig(model)
607
+ result = rsp.to_json_string()
608
+ try:
609
+ json_obj = json.loads(result)
610
+ except TypeError as e:
611
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
612
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
613
+ break
614
+ cur_time = time.time()
615
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
616
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
617
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
618
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
619
+ else:
620
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
621
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
622
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
623
+
624
+
625
+ def doDescribeDBInstanceNamespace(args, parsed_globals):
626
+ g_param = parse_global_arg(parsed_globals)
627
+
628
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
629
+ cred = credential.CVMRoleCredential()
630
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
631
+ cred = credential.STSAssumeRoleCredential(
632
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
633
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
634
+ )
635
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
636
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
637
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
638
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
639
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
640
+ else:
641
+ cred = credential.Credential(
642
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
643
+ )
644
+ http_profile = HttpProfile(
645
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
646
+ reqMethod="POST",
647
+ endpoint=g_param[OptionsDefine.Endpoint],
648
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
649
+ )
650
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
651
+ if g_param[OptionsDefine.Language]:
652
+ profile.language = g_param[OptionsDefine.Language]
653
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
654
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
655
+ client._sdkVersion += ("_CLI_" + __version__)
656
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
657
+ model = models.DescribeDBInstanceNamespaceRequest()
658
+ model.from_json_string(json.dumps(args))
659
+ start_time = time.time()
660
+ while True:
661
+ rsp = client.DescribeDBInstanceNamespace(model)
662
+ result = rsp.to_json_string()
663
+ try:
664
+ json_obj = json.loads(result)
665
+ except TypeError as e:
666
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
667
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
668
+ break
669
+ cur_time = time.time()
670
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
671
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
672
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
673
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
674
+ else:
675
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
676
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
677
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
678
+
679
+
680
+ def doDeleteLogDownloadTask(args, parsed_globals):
681
+ g_param = parse_global_arg(parsed_globals)
682
+
683
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
684
+ cred = credential.CVMRoleCredential()
685
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
686
+ cred = credential.STSAssumeRoleCredential(
687
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
688
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
689
+ )
690
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
691
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
692
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
693
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
694
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
695
+ else:
696
+ cred = credential.Credential(
697
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
698
+ )
699
+ http_profile = HttpProfile(
700
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
701
+ reqMethod="POST",
702
+ endpoint=g_param[OptionsDefine.Endpoint],
703
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
704
+ )
705
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
706
+ if g_param[OptionsDefine.Language]:
707
+ profile.language = g_param[OptionsDefine.Language]
708
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
709
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
710
+ client._sdkVersion += ("_CLI_" + __version__)
711
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
712
+ model = models.DeleteLogDownloadTaskRequest()
713
+ model.from_json_string(json.dumps(args))
714
+ start_time = time.time()
715
+ while True:
716
+ rsp = client.DeleteLogDownloadTask(model)
717
+ result = rsp.to_json_string()
718
+ try:
719
+ json_obj = json.loads(result)
720
+ except TypeError as e:
721
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
722
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
723
+ break
724
+ cur_time = time.time()
725
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
726
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
727
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
728
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
729
+ else:
730
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
731
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
732
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
733
+
734
+
735
+ def doDescribeDetailedSlowLogs(args, parsed_globals):
736
+ g_param = parse_global_arg(parsed_globals)
737
+
738
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
739
+ cred = credential.CVMRoleCredential()
740
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
741
+ cred = credential.STSAssumeRoleCredential(
742
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
743
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
744
+ )
745
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
746
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
747
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
748
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
749
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
750
+ else:
751
+ cred = credential.Credential(
752
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
753
+ )
754
+ http_profile = HttpProfile(
755
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
756
+ reqMethod="POST",
757
+ endpoint=g_param[OptionsDefine.Endpoint],
758
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
759
+ )
760
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
761
+ if g_param[OptionsDefine.Language]:
762
+ profile.language = g_param[OptionsDefine.Language]
763
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
764
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
765
+ client._sdkVersion += ("_CLI_" + __version__)
766
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
767
+ model = models.DescribeDetailedSlowLogsRequest()
768
+ model.from_json_string(json.dumps(args))
769
+ start_time = time.time()
770
+ while True:
771
+ rsp = client.DescribeDetailedSlowLogs(model)
772
+ result = rsp.to_json_string()
773
+ try:
774
+ json_obj = json.loads(result)
775
+ except TypeError as e:
776
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
777
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
778
+ break
779
+ cur_time = time.time()
780
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
781
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
782
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
783
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
784
+ else:
785
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
786
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
787
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
788
+
789
+
790
+ def doInstanceEnableSSL(args, parsed_globals):
791
+ g_param = parse_global_arg(parsed_globals)
792
+
793
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
794
+ cred = credential.CVMRoleCredential()
795
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
796
+ cred = credential.STSAssumeRoleCredential(
797
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
798
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
799
+ )
800
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
801
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
802
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
803
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
804
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
805
+ else:
806
+ cred = credential.Credential(
807
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
808
+ )
809
+ http_profile = HttpProfile(
810
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
811
+ reqMethod="POST",
812
+ endpoint=g_param[OptionsDefine.Endpoint],
813
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
814
+ )
815
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
816
+ if g_param[OptionsDefine.Language]:
817
+ profile.language = g_param[OptionsDefine.Language]
818
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
819
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
820
+ client._sdkVersion += ("_CLI_" + __version__)
821
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
822
+ model = models.InstanceEnableSSLRequest()
823
+ model.from_json_string(json.dumps(args))
824
+ start_time = time.time()
825
+ while True:
826
+ rsp = client.InstanceEnableSSL(model)
827
+ result = rsp.to_json_string()
828
+ try:
829
+ json_obj = json.loads(result)
830
+ except TypeError as e:
831
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
832
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
833
+ break
834
+ cur_time = time.time()
835
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
836
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
837
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
838
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
839
+ else:
840
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
841
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
842
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
843
+
844
+
845
+ def doInquirePriceModifyDBInstanceSpec(args, parsed_globals):
846
+ g_param = parse_global_arg(parsed_globals)
847
+
848
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
849
+ cred = credential.CVMRoleCredential()
850
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
851
+ cred = credential.STSAssumeRoleCredential(
852
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
853
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
854
+ )
855
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
856
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
857
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
858
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
859
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
860
+ else:
861
+ cred = credential.Credential(
862
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
863
+ )
864
+ http_profile = HttpProfile(
865
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
866
+ reqMethod="POST",
867
+ endpoint=g_param[OptionsDefine.Endpoint],
868
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
869
+ )
870
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
871
+ if g_param[OptionsDefine.Language]:
872
+ profile.language = g_param[OptionsDefine.Language]
873
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
874
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
875
+ client._sdkVersion += ("_CLI_" + __version__)
876
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
877
+ model = models.InquirePriceModifyDBInstanceSpecRequest()
878
+ model.from_json_string(json.dumps(args))
879
+ start_time = time.time()
880
+ while True:
881
+ rsp = client.InquirePriceModifyDBInstanceSpec(model)
882
+ result = rsp.to_json_string()
883
+ try:
884
+ json_obj = json.loads(result)
885
+ except TypeError as e:
886
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
887
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
888
+ break
889
+ cur_time = time.time()
890
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
891
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
892
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
893
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
894
+ else:
895
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
896
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
897
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
898
+
899
+
900
+ def doDescribeLogDownloadTasks(args, parsed_globals):
901
+ g_param = parse_global_arg(parsed_globals)
902
+
903
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
904
+ cred = credential.CVMRoleCredential()
905
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
906
+ cred = credential.STSAssumeRoleCredential(
907
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
908
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
909
+ )
910
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
911
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
912
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
913
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
914
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
915
+ else:
916
+ cred = credential.Credential(
917
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
918
+ )
919
+ http_profile = HttpProfile(
920
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
921
+ reqMethod="POST",
922
+ endpoint=g_param[OptionsDefine.Endpoint],
923
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
924
+ )
925
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
926
+ if g_param[OptionsDefine.Language]:
927
+ profile.language = g_param[OptionsDefine.Language]
928
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
929
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
930
+ client._sdkVersion += ("_CLI_" + __version__)
931
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
932
+ model = models.DescribeLogDownloadTasksRequest()
933
+ model.from_json_string(json.dumps(args))
934
+ start_time = time.time()
935
+ while True:
936
+ rsp = client.DescribeLogDownloadTasks(model)
937
+ result = rsp.to_json_string()
938
+ try:
939
+ json_obj = json.loads(result)
940
+ except TypeError as e:
941
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
942
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
943
+ break
944
+ cur_time = time.time()
945
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
946
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
947
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
948
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
949
+ else:
950
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
951
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
952
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
953
+
954
+
955
+ def doDescribeBackupRules(args, parsed_globals):
956
+ g_param = parse_global_arg(parsed_globals)
957
+
958
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
959
+ cred = credential.CVMRoleCredential()
960
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
961
+ cred = credential.STSAssumeRoleCredential(
962
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
963
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
964
+ )
965
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
966
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
967
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
968
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
969
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
970
+ else:
971
+ cred = credential.Credential(
972
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
973
+ )
974
+ http_profile = HttpProfile(
975
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
976
+ reqMethod="POST",
977
+ endpoint=g_param[OptionsDefine.Endpoint],
978
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
979
+ )
980
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
981
+ if g_param[OptionsDefine.Language]:
982
+ profile.language = g_param[OptionsDefine.Language]
983
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
984
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
985
+ client._sdkVersion += ("_CLI_" + __version__)
986
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
987
+ model = models.DescribeBackupRulesRequest()
108
988
  model.from_json_string(json.dumps(args))
109
989
  start_time = time.time()
110
990
  while True:
111
- rsp = client.DescribeDBInstanceNodeProperty(model)
991
+ rsp = client.DescribeBackupRules(model)
112
992
  result = rsp.to_json_string()
113
993
  try:
114
994
  json_obj = json.loads(result)
@@ -127,7 +1007,7 @@ def doDescribeDBInstanceNodeProperty(args, parsed_globals):
127
1007
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
128
1008
 
129
1009
 
130
- def doDescribeDBInstanceDeal(args, parsed_globals):
1010
+ def doRenameInstance(args, parsed_globals):
131
1011
  g_param = parse_global_arg(parsed_globals)
132
1012
 
133
1013
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -159,11 +1039,11 @@ def doDescribeDBInstanceDeal(args, parsed_globals):
159
1039
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
160
1040
  client._sdkVersion += ("_CLI_" + __version__)
161
1041
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
162
- model = models.DescribeDBInstanceDealRequest()
1042
+ model = models.RenameInstanceRequest()
163
1043
  model.from_json_string(json.dumps(args))
164
1044
  start_time = time.time()
165
1045
  while True:
166
- rsp = client.DescribeDBInstanceDeal(model)
1046
+ rsp = client.RenameInstance(model)
167
1047
  result = rsp.to_json_string()
168
1048
  try:
169
1049
  json_obj = json.loads(result)
@@ -182,7 +1062,7 @@ def doDescribeDBInstanceDeal(args, parsed_globals):
182
1062
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
183
1063
 
184
1064
 
185
- def doDescribeDBInstanceNamespace(args, parsed_globals):
1065
+ def doDescribeAsyncRequestInfo(args, parsed_globals):
186
1066
  g_param = parse_global_arg(parsed_globals)
187
1067
 
188
1068
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -214,11 +1094,11 @@ def doDescribeDBInstanceNamespace(args, parsed_globals):
214
1094
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
215
1095
  client._sdkVersion += ("_CLI_" + __version__)
216
1096
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
217
- model = models.DescribeDBInstanceNamespaceRequest()
1097
+ model = models.DescribeAsyncRequestInfoRequest()
218
1098
  model.from_json_string(json.dumps(args))
219
1099
  start_time = time.time()
220
1100
  while True:
221
- rsp = client.DescribeDBInstanceNamespace(model)
1101
+ rsp = client.DescribeAsyncRequestInfo(model)
222
1102
  result = rsp.to_json_string()
223
1103
  try:
224
1104
  json_obj = json.loads(result)
@@ -237,7 +1117,7 @@ def doDescribeDBInstanceNamespace(args, parsed_globals):
237
1117
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
238
1118
 
239
1119
 
240
- def doDescribeClientConnections(args, parsed_globals):
1120
+ def doCreateAccountUser(args, parsed_globals):
241
1121
  g_param = parse_global_arg(parsed_globals)
242
1122
 
243
1123
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -269,11 +1149,11 @@ def doDescribeClientConnections(args, parsed_globals):
269
1149
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
270
1150
  client._sdkVersion += ("_CLI_" + __version__)
271
1151
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
272
- model = models.DescribeClientConnectionsRequest()
1152
+ model = models.CreateAccountUserRequest()
273
1153
  model.from_json_string(json.dumps(args))
274
1154
  start_time = time.time()
275
1155
  while True:
276
- rsp = client.DescribeClientConnections(model)
1156
+ rsp = client.CreateAccountUser(model)
277
1157
  result = rsp.to_json_string()
278
1158
  try:
279
1159
  json_obj = json.loads(result)
@@ -292,7 +1172,7 @@ def doDescribeClientConnections(args, parsed_globals):
292
1172
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
293
1173
 
294
1174
 
295
- def doResetDBInstancePassword(args, parsed_globals):
1175
+ def doCreateDBInstanceHour(args, parsed_globals):
296
1176
  g_param = parse_global_arg(parsed_globals)
297
1177
 
298
1178
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -324,11 +1204,11 @@ def doResetDBInstancePassword(args, parsed_globals):
324
1204
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
325
1205
  client._sdkVersion += ("_CLI_" + __version__)
326
1206
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
327
- model = models.ResetDBInstancePasswordRequest()
1207
+ model = models.CreateDBInstanceHourRequest()
328
1208
  model.from_json_string(json.dumps(args))
329
1209
  start_time = time.time()
330
1210
  while True:
331
- rsp = client.ResetDBInstancePassword(model)
1211
+ rsp = client.CreateDBInstanceHour(model)
332
1212
  result = rsp.to_json_string()
333
1213
  try:
334
1214
  json_obj = json.loads(result)
@@ -347,7 +1227,7 @@ def doResetDBInstancePassword(args, parsed_globals):
347
1227
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
348
1228
 
349
1229
 
350
- def doDescribeSecurityGroup(args, parsed_globals):
1230
+ def doIsolateDBInstance(args, parsed_globals):
351
1231
  g_param = parse_global_arg(parsed_globals)
352
1232
 
353
1233
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -379,11 +1259,11 @@ def doDescribeSecurityGroup(args, parsed_globals):
379
1259
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
380
1260
  client._sdkVersion += ("_CLI_" + __version__)
381
1261
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
382
- model = models.DescribeSecurityGroupRequest()
1262
+ model = models.IsolateDBInstanceRequest()
383
1263
  model.from_json_string(json.dumps(args))
384
1264
  start_time = time.time()
385
1265
  while True:
386
- rsp = client.DescribeSecurityGroup(model)
1266
+ rsp = client.IsolateDBInstance(model)
387
1267
  result = rsp.to_json_string()
388
1268
  try:
389
1269
  json_obj = json.loads(result)
@@ -402,7 +1282,7 @@ def doDescribeSecurityGroup(args, parsed_globals):
402
1282
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
403
1283
 
404
1284
 
405
- def doFlushInstanceRouterConfig(args, parsed_globals):
1285
+ def doKillOps(args, parsed_globals):
406
1286
  g_param = parse_global_arg(parsed_globals)
407
1287
 
408
1288
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -434,11 +1314,11 @@ def doFlushInstanceRouterConfig(args, parsed_globals):
434
1314
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
435
1315
  client._sdkVersion += ("_CLI_" + __version__)
436
1316
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
437
- model = models.FlushInstanceRouterConfigRequest()
1317
+ model = models.KillOpsRequest()
438
1318
  model.from_json_string(json.dumps(args))
439
1319
  start_time = time.time()
440
1320
  while True:
441
- rsp = client.FlushInstanceRouterConfig(model)
1321
+ rsp = client.KillOps(model)
442
1322
  result = rsp.to_json_string()
443
1323
  try:
444
1324
  json_obj = json.loads(result)
@@ -457,7 +1337,7 @@ def doFlushInstanceRouterConfig(args, parsed_globals):
457
1337
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
458
1338
 
459
1339
 
460
- def doDescribeDBBackups(args, parsed_globals):
1340
+ def doCreateBackupDownloadTask(args, parsed_globals):
461
1341
  g_param = parse_global_arg(parsed_globals)
462
1342
 
463
1343
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -489,11 +1369,11 @@ def doDescribeDBBackups(args, parsed_globals):
489
1369
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
490
1370
  client._sdkVersion += ("_CLI_" + __version__)
491
1371
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
492
- model = models.DescribeDBBackupsRequest()
1372
+ model = models.CreateBackupDownloadTaskRequest()
493
1373
  model.from_json_string(json.dumps(args))
494
1374
  start_time = time.time()
495
1375
  while True:
496
- rsp = client.DescribeDBBackups(model)
1376
+ rsp = client.CreateBackupDownloadTask(model)
497
1377
  result = rsp.to_json_string()
498
1378
  try:
499
1379
  json_obj = json.loads(result)
@@ -512,7 +1392,7 @@ def doDescribeDBBackups(args, parsed_globals):
512
1392
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
513
1393
 
514
1394
 
515
- def doIsolateDBInstance(args, parsed_globals):
1395
+ def doCreateBackupDBInstance(args, parsed_globals):
516
1396
  g_param = parse_global_arg(parsed_globals)
517
1397
 
518
1398
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -544,11 +1424,11 @@ def doIsolateDBInstance(args, parsed_globals):
544
1424
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
545
1425
  client._sdkVersion += ("_CLI_" + __version__)
546
1426
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
547
- model = models.IsolateDBInstanceRequest()
1427
+ model = models.CreateBackupDBInstanceRequest()
548
1428
  model.from_json_string(json.dumps(args))
549
1429
  start_time = time.time()
550
1430
  while True:
551
- rsp = client.IsolateDBInstance(model)
1431
+ rsp = client.CreateBackupDBInstance(model)
552
1432
  result = rsp.to_json_string()
553
1433
  try:
554
1434
  json_obj = json.loads(result)
@@ -567,7 +1447,7 @@ def doIsolateDBInstance(args, parsed_globals):
567
1447
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
568
1448
 
569
1449
 
570
- def doInquirePriceModifyDBInstanceSpec(args, parsed_globals):
1450
+ def doDescribeDBInstances(args, parsed_globals):
571
1451
  g_param = parse_global_arg(parsed_globals)
572
1452
 
573
1453
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -599,11 +1479,11 @@ def doInquirePriceModifyDBInstanceSpec(args, parsed_globals):
599
1479
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
600
1480
  client._sdkVersion += ("_CLI_" + __version__)
601
1481
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
602
- model = models.InquirePriceModifyDBInstanceSpecRequest()
1482
+ model = models.DescribeDBInstancesRequest()
603
1483
  model.from_json_string(json.dumps(args))
604
1484
  start_time = time.time()
605
1485
  while True:
606
- rsp = client.InquirePriceModifyDBInstanceSpec(model)
1486
+ rsp = client.DescribeDBInstances(model)
607
1487
  result = rsp.to_json_string()
608
1488
  try:
609
1489
  json_obj = json.loads(result)
@@ -622,7 +1502,7 @@ def doInquirePriceModifyDBInstanceSpec(args, parsed_globals):
622
1502
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
623
1503
 
624
1504
 
625
- def doDescribeAsyncRequestInfo(args, parsed_globals):
1505
+ def doOfflineIsolatedDBInstance(args, parsed_globals):
626
1506
  g_param = parse_global_arg(parsed_globals)
627
1507
 
628
1508
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -654,11 +1534,11 @@ def doDescribeAsyncRequestInfo(args, parsed_globals):
654
1534
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
655
1535
  client._sdkVersion += ("_CLI_" + __version__)
656
1536
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
657
- model = models.DescribeAsyncRequestInfoRequest()
1537
+ model = models.OfflineIsolatedDBInstanceRequest()
658
1538
  model.from_json_string(json.dumps(args))
659
1539
  start_time = time.time()
660
1540
  while True:
661
- rsp = client.DescribeAsyncRequestInfo(model)
1541
+ rsp = client.OfflineIsolatedDBInstance(model)
662
1542
  result = rsp.to_json_string()
663
1543
  try:
664
1544
  json_obj = json.loads(result)
@@ -677,7 +1557,7 @@ def doDescribeAsyncRequestInfo(args, parsed_globals):
677
1557
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
678
1558
 
679
1559
 
680
- def doModifyDBInstanceNetworkAddress(args, parsed_globals):
1560
+ def doDescribeSlowLogPatterns(args, parsed_globals):
681
1561
  g_param = parse_global_arg(parsed_globals)
682
1562
 
683
1563
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -709,11 +1589,11 @@ def doModifyDBInstanceNetworkAddress(args, parsed_globals):
709
1589
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
710
1590
  client._sdkVersion += ("_CLI_" + __version__)
711
1591
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
712
- model = models.ModifyDBInstanceNetworkAddressRequest()
1592
+ model = models.DescribeSlowLogPatternsRequest()
713
1593
  model.from_json_string(json.dumps(args))
714
1594
  start_time = time.time()
715
1595
  while True:
716
- rsp = client.ModifyDBInstanceNetworkAddress(model)
1596
+ rsp = client.DescribeSlowLogPatterns(model)
717
1597
  result = rsp.to_json_string()
718
1598
  try:
719
1599
  json_obj = json.loads(result)
@@ -732,7 +1612,7 @@ def doModifyDBInstanceNetworkAddress(args, parsed_globals):
732
1612
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
733
1613
 
734
1614
 
735
- def doCreateDBInstanceHour(args, parsed_globals):
1615
+ def doDescribeSlowLogs(args, parsed_globals):
736
1616
  g_param = parse_global_arg(parsed_globals)
737
1617
 
738
1618
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -764,11 +1644,11 @@ def doCreateDBInstanceHour(args, parsed_globals):
764
1644
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
765
1645
  client._sdkVersion += ("_CLI_" + __version__)
766
1646
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
767
- model = models.CreateDBInstanceHourRequest()
1647
+ model = models.DescribeSlowLogsRequest()
768
1648
  model.from_json_string(json.dumps(args))
769
1649
  start_time = time.time()
770
1650
  while True:
771
- rsp = client.CreateDBInstanceHour(model)
1651
+ rsp = client.DescribeSlowLogs(model)
772
1652
  result = rsp.to_json_string()
773
1653
  try:
774
1654
  json_obj = json.loads(result)
@@ -787,7 +1667,7 @@ def doCreateDBInstanceHour(args, parsed_globals):
787
1667
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
788
1668
 
789
1669
 
790
- def doDescribeDetailedSlowLogs(args, parsed_globals):
1670
+ def doDescribeMongodbLogs(args, parsed_globals):
791
1671
  g_param = parse_global_arg(parsed_globals)
792
1672
 
793
1673
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -819,11 +1699,11 @@ def doDescribeDetailedSlowLogs(args, parsed_globals):
819
1699
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
820
1700
  client._sdkVersion += ("_CLI_" + __version__)
821
1701
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
822
- model = models.DescribeDetailedSlowLogsRequest()
1702
+ model = models.DescribeMongodbLogsRequest()
823
1703
  model.from_json_string(json.dumps(args))
824
1704
  start_time = time.time()
825
1705
  while True:
826
- rsp = client.DescribeDetailedSlowLogs(model)
1706
+ rsp = client.DescribeMongodbLogs(model)
827
1707
  result = rsp.to_json_string()
828
1708
  try:
829
1709
  json_obj = json.loads(result)
@@ -842,7 +1722,7 @@ def doDescribeDetailedSlowLogs(args, parsed_globals):
842
1722
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
843
1723
 
844
1724
 
845
- def doCreateBackupDownloadTask(args, parsed_globals):
1725
+ def doCreateDBInstance(args, parsed_globals):
846
1726
  g_param = parse_global_arg(parsed_globals)
847
1727
 
848
1728
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -874,11 +1754,11 @@ def doCreateBackupDownloadTask(args, parsed_globals):
874
1754
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
875
1755
  client._sdkVersion += ("_CLI_" + __version__)
876
1756
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
877
- model = models.CreateBackupDownloadTaskRequest()
1757
+ model = models.CreateDBInstanceRequest()
878
1758
  model.from_json_string(json.dumps(args))
879
1759
  start_time = time.time()
880
1760
  while True:
881
- rsp = client.CreateBackupDownloadTask(model)
1761
+ rsp = client.CreateDBInstance(model)
882
1762
  result = rsp.to_json_string()
883
1763
  try:
884
1764
  json_obj = json.loads(result)
@@ -897,7 +1777,7 @@ def doCreateBackupDownloadTask(args, parsed_globals):
897
1777
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
898
1778
 
899
1779
 
900
- def doDescribeDBInstances(args, parsed_globals):
1780
+ def doModifyDBInstanceSpec(args, parsed_globals):
901
1781
  g_param = parse_global_arg(parsed_globals)
902
1782
 
903
1783
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -929,11 +1809,11 @@ def doDescribeDBInstances(args, parsed_globals):
929
1809
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
930
1810
  client._sdkVersion += ("_CLI_" + __version__)
931
1811
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
932
- model = models.DescribeDBInstancesRequest()
1812
+ model = models.ModifyDBInstanceSpecRequest()
933
1813
  model.from_json_string(json.dumps(args))
934
1814
  start_time = time.time()
935
1815
  while True:
936
- rsp = client.DescribeDBInstances(model)
1816
+ rsp = client.ModifyDBInstanceSpec(model)
937
1817
  result = rsp.to_json_string()
938
1818
  try:
939
1819
  json_obj = json.loads(result)
@@ -952,7 +1832,7 @@ def doDescribeDBInstances(args, parsed_globals):
952
1832
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
953
1833
 
954
1834
 
955
- def doOfflineIsolatedDBInstance(args, parsed_globals):
1835
+ def doDescribeInstanceParams(args, parsed_globals):
956
1836
  g_param = parse_global_arg(parsed_globals)
957
1837
 
958
1838
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -984,11 +1864,11 @@ def doOfflineIsolatedDBInstance(args, parsed_globals):
984
1864
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
985
1865
  client._sdkVersion += ("_CLI_" + __version__)
986
1866
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
987
- model = models.OfflineIsolatedDBInstanceRequest()
1867
+ model = models.DescribeInstanceParamsRequest()
988
1868
  model.from_json_string(json.dumps(args))
989
1869
  start_time = time.time()
990
1870
  while True:
991
- rsp = client.OfflineIsolatedDBInstance(model)
1871
+ rsp = client.DescribeInstanceParams(model)
992
1872
  result = rsp.to_json_string()
993
1873
  try:
994
1874
  json_obj = json.loads(result)
@@ -1007,7 +1887,7 @@ def doOfflineIsolatedDBInstance(args, parsed_globals):
1007
1887
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1008
1888
 
1009
1889
 
1010
- def doDescribeSlowLogPatterns(args, parsed_globals):
1890
+ def doUpgradeDBInstanceKernelVersion(args, parsed_globals):
1011
1891
  g_param = parse_global_arg(parsed_globals)
1012
1892
 
1013
1893
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1039,11 +1919,11 @@ def doDescribeSlowLogPatterns(args, parsed_globals):
1039
1919
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1040
1920
  client._sdkVersion += ("_CLI_" + __version__)
1041
1921
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1042
- model = models.DescribeSlowLogPatternsRequest()
1922
+ model = models.UpgradeDBInstanceKernelVersionRequest()
1043
1923
  model.from_json_string(json.dumps(args))
1044
1924
  start_time = time.time()
1045
1925
  while True:
1046
- rsp = client.DescribeSlowLogPatterns(model)
1926
+ rsp = client.UpgradeDBInstanceKernelVersion(model)
1047
1927
  result = rsp.to_json_string()
1048
1928
  try:
1049
1929
  json_obj = json.loads(result)
@@ -1062,7 +1942,7 @@ def doDescribeSlowLogPatterns(args, parsed_globals):
1062
1942
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1063
1943
 
1064
1944
 
1065
- def doDescribeSlowLogs(args, parsed_globals):
1945
+ def doDescribeSpecInfo(args, parsed_globals):
1066
1946
  g_param = parse_global_arg(parsed_globals)
1067
1947
 
1068
1948
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1094,11 +1974,11 @@ def doDescribeSlowLogs(args, parsed_globals):
1094
1974
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1095
1975
  client._sdkVersion += ("_CLI_" + __version__)
1096
1976
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1097
- model = models.DescribeSlowLogsRequest()
1977
+ model = models.DescribeSpecInfoRequest()
1098
1978
  model.from_json_string(json.dumps(args))
1099
1979
  start_time = time.time()
1100
1980
  while True:
1101
- rsp = client.DescribeSlowLogs(model)
1981
+ rsp = client.DescribeSpecInfo(model)
1102
1982
  result = rsp.to_json_string()
1103
1983
  try:
1104
1984
  json_obj = json.loads(result)
@@ -1117,7 +1997,7 @@ def doDescribeSlowLogs(args, parsed_globals):
1117
1997
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1118
1998
 
1119
1999
 
1120
- def doCreateDBInstance(args, parsed_globals):
2000
+ def doDescribeBackupDownloadTask(args, parsed_globals):
1121
2001
  g_param = parse_global_arg(parsed_globals)
1122
2002
 
1123
2003
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1149,11 +2029,11 @@ def doCreateDBInstance(args, parsed_globals):
1149
2029
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1150
2030
  client._sdkVersion += ("_CLI_" + __version__)
1151
2031
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1152
- model = models.CreateDBInstanceRequest()
2032
+ model = models.DescribeBackupDownloadTaskRequest()
1153
2033
  model.from_json_string(json.dumps(args))
1154
2034
  start_time = time.time()
1155
2035
  while True:
1156
- rsp = client.CreateDBInstance(model)
2036
+ rsp = client.DescribeBackupDownloadTask(model)
1157
2037
  result = rsp.to_json_string()
1158
2038
  try:
1159
2039
  json_obj = json.loads(result)
@@ -1172,7 +2052,7 @@ def doCreateDBInstance(args, parsed_globals):
1172
2052
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1173
2053
 
1174
2054
 
1175
- def doModifyDBInstanceSpec(args, parsed_globals):
2055
+ def doInquirePriceCreateDBInstances(args, parsed_globals):
1176
2056
  g_param = parse_global_arg(parsed_globals)
1177
2057
 
1178
2058
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1204,11 +2084,11 @@ def doModifyDBInstanceSpec(args, parsed_globals):
1204
2084
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1205
2085
  client._sdkVersion += ("_CLI_" + __version__)
1206
2086
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1207
- model = models.ModifyDBInstanceSpecRequest()
2087
+ model = models.InquirePriceCreateDBInstancesRequest()
1208
2088
  model.from_json_string(json.dumps(args))
1209
2089
  start_time = time.time()
1210
2090
  while True:
1211
- rsp = client.ModifyDBInstanceSpec(model)
2091
+ rsp = client.InquirePriceCreateDBInstances(model)
1212
2092
  result = rsp.to_json_string()
1213
2093
  try:
1214
2094
  json_obj = json.loads(result)
@@ -1227,7 +2107,7 @@ def doModifyDBInstanceSpec(args, parsed_globals):
1227
2107
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1228
2108
 
1229
2109
 
1230
- def doDescribeInstanceParams(args, parsed_globals):
2110
+ def doDescribeInstanceSSL(args, parsed_globals):
1231
2111
  g_param = parse_global_arg(parsed_globals)
1232
2112
 
1233
2113
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1259,11 +2139,11 @@ def doDescribeInstanceParams(args, parsed_globals):
1259
2139
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1260
2140
  client._sdkVersion += ("_CLI_" + __version__)
1261
2141
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1262
- model = models.DescribeInstanceParamsRequest()
2142
+ model = models.DescribeInstanceSSLRequest()
1263
2143
  model.from_json_string(json.dumps(args))
1264
2144
  start_time = time.time()
1265
2145
  while True:
1266
- rsp = client.DescribeInstanceParams(model)
2146
+ rsp = client.DescribeInstanceSSL(model)
1267
2147
  result = rsp.to_json_string()
1268
2148
  try:
1269
2149
  json_obj = json.loads(result)
@@ -1282,7 +2162,7 @@ def doDescribeInstanceParams(args, parsed_globals):
1282
2162
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1283
2163
 
1284
2164
 
1285
- def doDescribeSpecInfo(args, parsed_globals):
2165
+ def doSetDBInstanceDeletionProtection(args, parsed_globals):
1286
2166
  g_param = parse_global_arg(parsed_globals)
1287
2167
 
1288
2168
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1314,11 +2194,11 @@ def doDescribeSpecInfo(args, parsed_globals):
1314
2194
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1315
2195
  client._sdkVersion += ("_CLI_" + __version__)
1316
2196
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1317
- model = models.DescribeSpecInfoRequest()
2197
+ model = models.SetDBInstanceDeletionProtectionRequest()
1318
2198
  model.from_json_string(json.dumps(args))
1319
2199
  start_time = time.time()
1320
2200
  while True:
1321
- rsp = client.DescribeSpecInfo(model)
2201
+ rsp = client.SetDBInstanceDeletionProtection(model)
1322
2202
  result = rsp.to_json_string()
1323
2203
  try:
1324
2204
  json_obj = json.loads(result)
@@ -1337,7 +2217,7 @@ def doDescribeSpecInfo(args, parsed_globals):
1337
2217
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1338
2218
 
1339
2219
 
1340
- def doDescribeBackupDownloadTask(args, parsed_globals):
2220
+ def doAssignProject(args, parsed_globals):
1341
2221
  g_param = parse_global_arg(parsed_globals)
1342
2222
 
1343
2223
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1369,11 +2249,11 @@ def doDescribeBackupDownloadTask(args, parsed_globals):
1369
2249
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1370
2250
  client._sdkVersion += ("_CLI_" + __version__)
1371
2251
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1372
- model = models.DescribeBackupDownloadTaskRequest()
2252
+ model = models.AssignProjectRequest()
1373
2253
  model.from_json_string(json.dumps(args))
1374
2254
  start_time = time.time()
1375
2255
  while True:
1376
- rsp = client.DescribeBackupDownloadTask(model)
2256
+ rsp = client.AssignProject(model)
1377
2257
  result = rsp.to_json_string()
1378
2258
  try:
1379
2259
  json_obj = json.loads(result)
@@ -1392,7 +2272,7 @@ def doDescribeBackupDownloadTask(args, parsed_globals):
1392
2272
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1393
2273
 
1394
2274
 
1395
- def doInquirePriceCreateDBInstances(args, parsed_globals):
2275
+ def doUpgradeDbInstanceVersion(args, parsed_globals):
1396
2276
  g_param = parse_global_arg(parsed_globals)
1397
2277
 
1398
2278
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1424,11 +2304,11 @@ def doInquirePriceCreateDBInstances(args, parsed_globals):
1424
2304
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1425
2305
  client._sdkVersion += ("_CLI_" + __version__)
1426
2306
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1427
- model = models.InquirePriceCreateDBInstancesRequest()
2307
+ model = models.UpgradeDbInstanceVersionRequest()
1428
2308
  model.from_json_string(json.dumps(args))
1429
2309
  start_time = time.time()
1430
2310
  while True:
1431
- rsp = client.InquirePriceCreateDBInstances(model)
2311
+ rsp = client.UpgradeDbInstanceVersion(model)
1432
2312
  result = rsp.to_json_string()
1433
2313
  try:
1434
2314
  json_obj = json.loads(result)
@@ -1447,7 +2327,7 @@ def doInquirePriceCreateDBInstances(args, parsed_globals):
1447
2327
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1448
2328
 
1449
2329
 
1450
- def doSetDBInstanceDeletionProtection(args, parsed_globals):
2330
+ def doSetInstanceMaintenance(args, parsed_globals):
1451
2331
  g_param = parse_global_arg(parsed_globals)
1452
2332
 
1453
2333
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1479,11 +2359,11 @@ def doSetDBInstanceDeletionProtection(args, parsed_globals):
1479
2359
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1480
2360
  client._sdkVersion += ("_CLI_" + __version__)
1481
2361
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1482
- model = models.SetDBInstanceDeletionProtectionRequest()
2362
+ model = models.SetInstanceMaintenanceRequest()
1483
2363
  model.from_json_string(json.dumps(args))
1484
2364
  start_time = time.time()
1485
2365
  while True:
1486
- rsp = client.SetDBInstanceDeletionProtection(model)
2366
+ rsp = client.SetInstanceMaintenance(model)
1487
2367
  result = rsp.to_json_string()
1488
2368
  try:
1489
2369
  json_obj = json.loads(result)
@@ -1502,7 +2382,7 @@ def doSetDBInstanceDeletionProtection(args, parsed_globals):
1502
2382
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1503
2383
 
1504
2384
 
1505
- def doAssignProject(args, parsed_globals):
2385
+ def doModifyInstanceParams(args, parsed_globals):
1506
2386
  g_param = parse_global_arg(parsed_globals)
1507
2387
 
1508
2388
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1534,11 +2414,11 @@ def doAssignProject(args, parsed_globals):
1534
2414
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1535
2415
  client._sdkVersion += ("_CLI_" + __version__)
1536
2416
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1537
- model = models.AssignProjectRequest()
2417
+ model = models.ModifyInstanceParamsRequest()
1538
2418
  model.from_json_string(json.dumps(args))
1539
2419
  start_time = time.time()
1540
2420
  while True:
1541
- rsp = client.AssignProject(model)
2421
+ rsp = client.ModifyInstanceParams(model)
1542
2422
  result = rsp.to_json_string()
1543
2423
  try:
1544
2424
  json_obj = json.loads(result)
@@ -1557,7 +2437,7 @@ def doAssignProject(args, parsed_globals):
1557
2437
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1558
2438
 
1559
2439
 
1560
- def doRenameInstance(args, parsed_globals):
2440
+ def doRenewDBInstances(args, parsed_globals):
1561
2441
  g_param = parse_global_arg(parsed_globals)
1562
2442
 
1563
2443
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1589,11 +2469,11 @@ def doRenameInstance(args, parsed_globals):
1589
2469
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1590
2470
  client._sdkVersion += ("_CLI_" + __version__)
1591
2471
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1592
- model = models.RenameInstanceRequest()
2472
+ model = models.RenewDBInstancesRequest()
1593
2473
  model.from_json_string(json.dumps(args))
1594
2474
  start_time = time.time()
1595
2475
  while True:
1596
- rsp = client.RenameInstance(model)
2476
+ rsp = client.RenewDBInstances(model)
1597
2477
  result = rsp.to_json_string()
1598
2478
  try:
1599
2479
  json_obj = json.loads(result)
@@ -1612,7 +2492,7 @@ def doRenameInstance(args, parsed_globals):
1612
2492
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1613
2493
 
1614
2494
 
1615
- def doRenewDBInstances(args, parsed_globals):
2495
+ def doEnableTransparentDataEncryption(args, parsed_globals):
1616
2496
  g_param = parse_global_arg(parsed_globals)
1617
2497
 
1618
2498
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1644,11 +2524,11 @@ def doRenewDBInstances(args, parsed_globals):
1644
2524
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1645
2525
  client._sdkVersion += ("_CLI_" + __version__)
1646
2526
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1647
- model = models.RenewDBInstancesRequest()
2527
+ model = models.EnableTransparentDataEncryptionRequest()
1648
2528
  model.from_json_string(json.dumps(args))
1649
2529
  start_time = time.time()
1650
2530
  while True:
1651
- rsp = client.RenewDBInstances(model)
2531
+ rsp = client.EnableTransparentDataEncryption(model)
1652
2532
  result = rsp.to_json_string()
1653
2533
  try:
1654
2534
  json_obj = json.loads(result)
@@ -1667,7 +2547,7 @@ def doRenewDBInstances(args, parsed_globals):
1667
2547
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1668
2548
 
1669
2549
 
1670
- def doCreateBackupDBInstance(args, parsed_globals):
2550
+ def doModifyDBInstanceNetworkAddress(args, parsed_globals):
1671
2551
  g_param = parse_global_arg(parsed_globals)
1672
2552
 
1673
2553
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1699,11 +2579,11 @@ def doCreateBackupDBInstance(args, parsed_globals):
1699
2579
  client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
1700
2580
  client._sdkVersion += ("_CLI_" + __version__)
1701
2581
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1702
- model = models.CreateBackupDBInstanceRequest()
2582
+ model = models.ModifyDBInstanceNetworkAddressRequest()
1703
2583
  model.from_json_string(json.dumps(args))
1704
2584
  start_time = time.time()
1705
2585
  while True:
1706
- rsp = client.CreateBackupDBInstance(model)
2586
+ rsp = client.ModifyDBInstanceNetworkAddress(model)
1707
2587
  result = rsp.to_json_string()
1708
2588
  try:
1709
2589
  json_obj = json.loads(result)
@@ -1777,6 +2657,61 @@ def doInquirePriceRenewDBInstances(args, parsed_globals):
1777
2657
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1778
2658
 
1779
2659
 
2660
+ def doDeleteAccountUser(args, parsed_globals):
2661
+ g_param = parse_global_arg(parsed_globals)
2662
+
2663
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2664
+ cred = credential.CVMRoleCredential()
2665
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2666
+ cred = credential.STSAssumeRoleCredential(
2667
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2668
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2669
+ )
2670
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) \
2671
+ and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) \
2672
+ and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) \
2673
+ and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2674
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2675
+ else:
2676
+ cred = credential.Credential(
2677
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2678
+ )
2679
+ http_profile = HttpProfile(
2680
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2681
+ reqMethod="POST",
2682
+ endpoint=g_param[OptionsDefine.Endpoint],
2683
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2684
+ )
2685
+ profile = ClientProfile(httpProfile=http_profile, signMethod="TC3-HMAC-SHA256")
2686
+ if g_param[OptionsDefine.Language]:
2687
+ profile.language = g_param[OptionsDefine.Language]
2688
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2689
+ client = mod.MongodbClient(cred, g_param[OptionsDefine.Region], profile)
2690
+ client._sdkVersion += ("_CLI_" + __version__)
2691
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2692
+ model = models.DeleteAccountUserRequest()
2693
+ model.from_json_string(json.dumps(args))
2694
+ start_time = time.time()
2695
+ while True:
2696
+ rsp = client.DeleteAccountUser(model)
2697
+ result = rsp.to_json_string()
2698
+ try:
2699
+ json_obj = json.loads(result)
2700
+ except TypeError as e:
2701
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2702
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2703
+ break
2704
+ cur_time = time.time()
2705
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2706
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2707
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2708
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2709
+ else:
2710
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2711
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2712
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2713
+
2714
+
1780
2715
  def doModifyDBInstanceSecurityGroup(args, parsed_globals):
1781
2716
  g_param = parse_global_arg(parsed_globals)
1782
2717
 
@@ -1844,37 +2779,54 @@ MODELS_MAP = {
1844
2779
 
1845
2780
  ACTION_MAP = {
1846
2781
  "TerminateDBInstances": doTerminateDBInstances,
2782
+ "CreateLogDownloadTask": doCreateLogDownloadTask,
1847
2783
  "DescribeDBInstanceNodeProperty": doDescribeDBInstanceNodeProperty,
1848
2784
  "DescribeDBInstanceDeal": doDescribeDBInstanceDeal,
1849
- "DescribeDBInstanceNamespace": doDescribeDBInstanceNamespace,
2785
+ "DescribeCurrentOp": doDescribeCurrentOp,
2786
+ "DescribeDBBackups": doDescribeDBBackups,
1850
2787
  "DescribeClientConnections": doDescribeClientConnections,
1851
2788
  "ResetDBInstancePassword": doResetDBInstancePassword,
1852
2789
  "DescribeSecurityGroup": doDescribeSecurityGroup,
2790
+ "SetAccountUserPrivilege": doSetAccountUserPrivilege,
1853
2791
  "FlushInstanceRouterConfig": doFlushInstanceRouterConfig,
1854
- "DescribeDBBackups": doDescribeDBBackups,
1855
- "IsolateDBInstance": doIsolateDBInstance,
2792
+ "DescribeDBInstanceNamespace": doDescribeDBInstanceNamespace,
2793
+ "DeleteLogDownloadTask": doDeleteLogDownloadTask,
2794
+ "DescribeDetailedSlowLogs": doDescribeDetailedSlowLogs,
2795
+ "InstanceEnableSSL": doInstanceEnableSSL,
1856
2796
  "InquirePriceModifyDBInstanceSpec": doInquirePriceModifyDBInstanceSpec,
2797
+ "DescribeLogDownloadTasks": doDescribeLogDownloadTasks,
2798
+ "DescribeBackupRules": doDescribeBackupRules,
2799
+ "RenameInstance": doRenameInstance,
1857
2800
  "DescribeAsyncRequestInfo": doDescribeAsyncRequestInfo,
1858
- "ModifyDBInstanceNetworkAddress": doModifyDBInstanceNetworkAddress,
2801
+ "CreateAccountUser": doCreateAccountUser,
1859
2802
  "CreateDBInstanceHour": doCreateDBInstanceHour,
1860
- "DescribeDetailedSlowLogs": doDescribeDetailedSlowLogs,
2803
+ "IsolateDBInstance": doIsolateDBInstance,
2804
+ "KillOps": doKillOps,
1861
2805
  "CreateBackupDownloadTask": doCreateBackupDownloadTask,
2806
+ "CreateBackupDBInstance": doCreateBackupDBInstance,
1862
2807
  "DescribeDBInstances": doDescribeDBInstances,
1863
2808
  "OfflineIsolatedDBInstance": doOfflineIsolatedDBInstance,
1864
2809
  "DescribeSlowLogPatterns": doDescribeSlowLogPatterns,
1865
2810
  "DescribeSlowLogs": doDescribeSlowLogs,
2811
+ "DescribeMongodbLogs": doDescribeMongodbLogs,
1866
2812
  "CreateDBInstance": doCreateDBInstance,
1867
2813
  "ModifyDBInstanceSpec": doModifyDBInstanceSpec,
1868
2814
  "DescribeInstanceParams": doDescribeInstanceParams,
2815
+ "UpgradeDBInstanceKernelVersion": doUpgradeDBInstanceKernelVersion,
1869
2816
  "DescribeSpecInfo": doDescribeSpecInfo,
1870
2817
  "DescribeBackupDownloadTask": doDescribeBackupDownloadTask,
1871
2818
  "InquirePriceCreateDBInstances": doInquirePriceCreateDBInstances,
2819
+ "DescribeInstanceSSL": doDescribeInstanceSSL,
1872
2820
  "SetDBInstanceDeletionProtection": doSetDBInstanceDeletionProtection,
1873
2821
  "AssignProject": doAssignProject,
1874
- "RenameInstance": doRenameInstance,
2822
+ "UpgradeDbInstanceVersion": doUpgradeDbInstanceVersion,
2823
+ "SetInstanceMaintenance": doSetInstanceMaintenance,
2824
+ "ModifyInstanceParams": doModifyInstanceParams,
1875
2825
  "RenewDBInstances": doRenewDBInstances,
1876
- "CreateBackupDBInstance": doCreateBackupDBInstance,
2826
+ "EnableTransparentDataEncryption": doEnableTransparentDataEncryption,
2827
+ "ModifyDBInstanceNetworkAddress": doModifyDBInstanceNetworkAddress,
1877
2828
  "InquirePriceRenewDBInstances": doInquirePriceRenewDBInstances,
2829
+ "DeleteAccountUser": doDeleteAccountUser,
1878
2830
  "ModifyDBInstanceSecurityGroup": doModifyDBInstanceSecurityGroup,
1879
2831
 
1880
2832
  }