tccli-intl-en 3.0.1256.1__py2.py3-none-any.whl → 3.0.1258.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 (20) hide show
  1. tccli/__init__.py +1 -1
  2. tccli/services/cdc/v20201214/api.json +2 -2
  3. tccli/services/cdc/v20201214/examples.json +4 -4
  4. tccli/services/emr/emr_client.py +2522 -84
  5. tccli/services/emr/v20190103/api.json +14527 -4841
  6. tccli/services/emr/v20190103/examples.json +404 -36
  7. tccli/services/lighthouse/v20200324/api.json +14 -14
  8. tccli/services/lighthouse/v20200324/examples.json +5 -5
  9. tccli/services/sqlserver/sqlserver_client.py +53 -0
  10. tccli/services/sqlserver/v20180328/api.json +100 -0
  11. tccli/services/sqlserver/v20180328/examples.json +8 -0
  12. tccli/services/tcsas/v20250106/api.json +54 -18
  13. tccli/services/tcsas/v20250106/examples.json +1 -1
  14. tccli/services/teo/v20220901/api.json +16 -7
  15. {tccli_intl_en-3.0.1256.1.dist-info → tccli_intl_en-3.0.1258.1.dist-info}/METADATA +2 -2
  16. {tccli_intl_en-3.0.1256.1.dist-info → tccli_intl_en-3.0.1258.1.dist-info}/RECORD +20 -20
  17. {tccli_intl_en-3.0.1256.1.dist-info → tccli_intl_en-3.0.1258.1.dist-info}/LICENSE +0 -0
  18. {tccli_intl_en-3.0.1256.1.dist-info → tccli_intl_en-3.0.1258.1.dist-info}/WHEEL +0 -0
  19. {tccli_intl_en-3.0.1256.1.dist-info → tccli_intl_en-3.0.1258.1.dist-info}/entry_points.txt +0 -0
  20. {tccli_intl_en-3.0.1256.1.dist-info → tccli_intl_en-3.0.1258.1.dist-info}/top_level.txt +0 -0
tccli/services/emr/emr_client.py CHANGED
@@ -173,6 +173,58 @@ def doCreateCluster(args, parsed_globals):
173
173
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
174
174
 
175
175
 
176
+ def doDescribeServiceConfGroupInfos(args, parsed_globals):
177
+ g_param = parse_global_arg(parsed_globals)
178
+
179
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
180
+ cred = credential.CVMRoleCredential()
181
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
182
+ cred = credential.STSAssumeRoleCredential(
183
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
184
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
185
+ )
186
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
187
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
188
+ else:
189
+ cred = credential.Credential(
190
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
191
+ )
192
+ http_profile = HttpProfile(
193
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
194
+ reqMethod="POST",
195
+ endpoint=g_param[OptionsDefine.Endpoint],
196
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
197
+ )
198
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
199
+ if g_param[OptionsDefine.Language]:
200
+ profile.language = g_param[OptionsDefine.Language]
201
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
202
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
203
+ client._sdkVersion += ("_CLI_" + __version__)
204
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
205
+ model = models.DescribeServiceConfGroupInfosRequest()
206
+ model.from_json_string(json.dumps(args))
207
+ start_time = time.time()
208
+ while True:
209
+ rsp = client.DescribeServiceConfGroupInfos(model)
210
+ result = rsp.to_json_string()
211
+ try:
212
+ json_obj = json.loads(result)
213
+ except TypeError as e:
214
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
215
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
216
+ break
217
+ cur_time = time.time()
218
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
219
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
220
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
221
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
222
+ else:
223
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
224
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
225
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
226
+
227
+
176
228
  def doInquiryPriceRenewInstance(args, parsed_globals):
177
229
  g_param = parse_global_arg(parsed_globals)
178
230
 
@@ -202,11 +254,2247 @@ def doInquiryPriceRenewInstance(args, parsed_globals):
202
254
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
203
255
  client._sdkVersion += ("_CLI_" + __version__)
204
256
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
205
- model = models.InquiryPriceRenewInstanceRequest()
257
+ model = models.InquiryPriceRenewInstanceRequest()
258
+ model.from_json_string(json.dumps(args))
259
+ start_time = time.time()
260
+ while True:
261
+ rsp = client.InquiryPriceRenewInstance(model)
262
+ result = rsp.to_json_string()
263
+ try:
264
+ json_obj = json.loads(result)
265
+ except TypeError as e:
266
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
267
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
268
+ break
269
+ cur_time = time.time()
270
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
271
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
272
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
273
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
274
+ else:
275
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
276
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
277
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
278
+
279
+
280
+ def doDescribeGroupsSTD(args, parsed_globals):
281
+ g_param = parse_global_arg(parsed_globals)
282
+
283
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
284
+ cred = credential.CVMRoleCredential()
285
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
286
+ cred = credential.STSAssumeRoleCredential(
287
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
288
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
289
+ )
290
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
291
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
292
+ else:
293
+ cred = credential.Credential(
294
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
295
+ )
296
+ http_profile = HttpProfile(
297
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
298
+ reqMethod="POST",
299
+ endpoint=g_param[OptionsDefine.Endpoint],
300
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
301
+ )
302
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
303
+ if g_param[OptionsDefine.Language]:
304
+ profile.language = g_param[OptionsDefine.Language]
305
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
306
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
307
+ client._sdkVersion += ("_CLI_" + __version__)
308
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
309
+ model = models.DescribeGroupsSTDRequest()
310
+ model.from_json_string(json.dumps(args))
311
+ start_time = time.time()
312
+ while True:
313
+ rsp = client.DescribeGroupsSTD(model)
314
+ result = rsp.to_json_string()
315
+ try:
316
+ json_obj = json.loads(result)
317
+ except TypeError as e:
318
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
319
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
320
+ break
321
+ cur_time = time.time()
322
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
323
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
324
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
325
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
326
+ else:
327
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
328
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
329
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
330
+
331
+
332
+ def doDescribeYarnQueue(args, parsed_globals):
333
+ g_param = parse_global_arg(parsed_globals)
334
+
335
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
336
+ cred = credential.CVMRoleCredential()
337
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
338
+ cred = credential.STSAssumeRoleCredential(
339
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
340
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
341
+ )
342
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
343
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
344
+ else:
345
+ cred = credential.Credential(
346
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
347
+ )
348
+ http_profile = HttpProfile(
349
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
350
+ reqMethod="POST",
351
+ endpoint=g_param[OptionsDefine.Endpoint],
352
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
353
+ )
354
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
355
+ if g_param[OptionsDefine.Language]:
356
+ profile.language = g_param[OptionsDefine.Language]
357
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
358
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
359
+ client._sdkVersion += ("_CLI_" + __version__)
360
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
361
+ model = models.DescribeYarnQueueRequest()
362
+ model.from_json_string(json.dumps(args))
363
+ start_time = time.time()
364
+ while True:
365
+ rsp = client.DescribeYarnQueue(model)
366
+ result = rsp.to_json_string()
367
+ try:
368
+ json_obj = json.loads(result)
369
+ except TypeError as e:
370
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
371
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
372
+ break
373
+ cur_time = time.time()
374
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
375
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
376
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
377
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
378
+ else:
379
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
380
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
381
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
382
+
383
+
384
+ def doModifyYarnQueueV2(args, parsed_globals):
385
+ g_param = parse_global_arg(parsed_globals)
386
+
387
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
388
+ cred = credential.CVMRoleCredential()
389
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
390
+ cred = credential.STSAssumeRoleCredential(
391
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
392
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
393
+ )
394
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
395
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
396
+ else:
397
+ cred = credential.Credential(
398
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
399
+ )
400
+ http_profile = HttpProfile(
401
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
402
+ reqMethod="POST",
403
+ endpoint=g_param[OptionsDefine.Endpoint],
404
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
405
+ )
406
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
407
+ if g_param[OptionsDefine.Language]:
408
+ profile.language = g_param[OptionsDefine.Language]
409
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
410
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
411
+ client._sdkVersion += ("_CLI_" + __version__)
412
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
413
+ model = models.ModifyYarnQueueV2Request()
414
+ model.from_json_string(json.dumps(args))
415
+ start_time = time.time()
416
+ while True:
417
+ rsp = client.ModifyYarnQueueV2(model)
418
+ result = rsp.to_json_string()
419
+ try:
420
+ json_obj = json.loads(result)
421
+ except TypeError as e:
422
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
423
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
424
+ break
425
+ cur_time = time.time()
426
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
427
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
428
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
429
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
430
+ else:
431
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
432
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
433
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
434
+
435
+
436
+ def doDeployYarnConf(args, parsed_globals):
437
+ g_param = parse_global_arg(parsed_globals)
438
+
439
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
440
+ cred = credential.CVMRoleCredential()
441
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
442
+ cred = credential.STSAssumeRoleCredential(
443
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
444
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
445
+ )
446
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
447
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
448
+ else:
449
+ cred = credential.Credential(
450
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
451
+ )
452
+ http_profile = HttpProfile(
453
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
454
+ reqMethod="POST",
455
+ endpoint=g_param[OptionsDefine.Endpoint],
456
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
457
+ )
458
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
459
+ if g_param[OptionsDefine.Language]:
460
+ profile.language = g_param[OptionsDefine.Language]
461
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
462
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
463
+ client._sdkVersion += ("_CLI_" + __version__)
464
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
465
+ model = models.DeployYarnConfRequest()
466
+ model.from_json_string(json.dumps(args))
467
+ start_time = time.time()
468
+ while True:
469
+ rsp = client.DeployYarnConf(model)
470
+ result = rsp.to_json_string()
471
+ try:
472
+ json_obj = json.loads(result)
473
+ except TypeError as e:
474
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
475
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
476
+ break
477
+ cur_time = time.time()
478
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
479
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
480
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
481
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
482
+ else:
483
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
484
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
485
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
486
+
487
+
488
+ def doDescribeClusterFlowStatusDetail(args, parsed_globals):
489
+ g_param = parse_global_arg(parsed_globals)
490
+
491
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
492
+ cred = credential.CVMRoleCredential()
493
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
494
+ cred = credential.STSAssumeRoleCredential(
495
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
496
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
497
+ )
498
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
499
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
500
+ else:
501
+ cred = credential.Credential(
502
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
503
+ )
504
+ http_profile = HttpProfile(
505
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
506
+ reqMethod="POST",
507
+ endpoint=g_param[OptionsDefine.Endpoint],
508
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
509
+ )
510
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
511
+ if g_param[OptionsDefine.Language]:
512
+ profile.language = g_param[OptionsDefine.Language]
513
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
514
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
515
+ client._sdkVersion += ("_CLI_" + __version__)
516
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
517
+ model = models.DescribeClusterFlowStatusDetailRequest()
518
+ model.from_json_string(json.dumps(args))
519
+ start_time = time.time()
520
+ while True:
521
+ rsp = client.DescribeClusterFlowStatusDetail(model)
522
+ result = rsp.to_json_string()
523
+ try:
524
+ json_obj = json.loads(result)
525
+ except TypeError as e:
526
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
527
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
528
+ break
529
+ cur_time = time.time()
530
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
531
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
532
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
533
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
534
+ else:
535
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
536
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
537
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
538
+
539
+
540
+ def doInquiryPriceScaleOutInstance(args, parsed_globals):
541
+ g_param = parse_global_arg(parsed_globals)
542
+
543
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
544
+ cred = credential.CVMRoleCredential()
545
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
546
+ cred = credential.STSAssumeRoleCredential(
547
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
548
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
549
+ )
550
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
551
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
552
+ else:
553
+ cred = credential.Credential(
554
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
555
+ )
556
+ http_profile = HttpProfile(
557
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
558
+ reqMethod="POST",
559
+ endpoint=g_param[OptionsDefine.Endpoint],
560
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
561
+ )
562
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
563
+ if g_param[OptionsDefine.Language]:
564
+ profile.language = g_param[OptionsDefine.Language]
565
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
566
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
567
+ client._sdkVersion += ("_CLI_" + __version__)
568
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
569
+ model = models.InquiryPriceScaleOutInstanceRequest()
570
+ model.from_json_string(json.dumps(args))
571
+ start_time = time.time()
572
+ while True:
573
+ rsp = client.InquiryPriceScaleOutInstance(model)
574
+ result = rsp.to_json_string()
575
+ try:
576
+ json_obj = json.loads(result)
577
+ except TypeError as e:
578
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
579
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
580
+ break
581
+ cur_time = time.time()
582
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
583
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
584
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
585
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
586
+ else:
587
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
588
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
589
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
590
+
591
+
592
+ def doDescribeAutoScaleRecords(args, parsed_globals):
593
+ g_param = parse_global_arg(parsed_globals)
594
+
595
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
596
+ cred = credential.CVMRoleCredential()
597
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
598
+ cred = credential.STSAssumeRoleCredential(
599
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
600
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
601
+ )
602
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
603
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
604
+ else:
605
+ cred = credential.Credential(
606
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
607
+ )
608
+ http_profile = HttpProfile(
609
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
610
+ reqMethod="POST",
611
+ endpoint=g_param[OptionsDefine.Endpoint],
612
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
613
+ )
614
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
615
+ if g_param[OptionsDefine.Language]:
616
+ profile.language = g_param[OptionsDefine.Language]
617
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
618
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
619
+ client._sdkVersion += ("_CLI_" + __version__)
620
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
621
+ model = models.DescribeAutoScaleRecordsRequest()
622
+ model.from_json_string(json.dumps(args))
623
+ start_time = time.time()
624
+ while True:
625
+ rsp = client.DescribeAutoScaleRecords(model)
626
+ result = rsp.to_json_string()
627
+ try:
628
+ json_obj = json.loads(result)
629
+ except TypeError as e:
630
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
631
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
632
+ break
633
+ cur_time = time.time()
634
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
635
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
636
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
637
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
638
+ else:
639
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
640
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
641
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
642
+
643
+
644
+ def doDescribeEmrOverviewMetrics(args, parsed_globals):
645
+ g_param = parse_global_arg(parsed_globals)
646
+
647
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
648
+ cred = credential.CVMRoleCredential()
649
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
650
+ cred = credential.STSAssumeRoleCredential(
651
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
652
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
653
+ )
654
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
655
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
656
+ else:
657
+ cred = credential.Credential(
658
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
659
+ )
660
+ http_profile = HttpProfile(
661
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
662
+ reqMethod="POST",
663
+ endpoint=g_param[OptionsDefine.Endpoint],
664
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
665
+ )
666
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
667
+ if g_param[OptionsDefine.Language]:
668
+ profile.language = g_param[OptionsDefine.Language]
669
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
670
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
671
+ client._sdkVersion += ("_CLI_" + __version__)
672
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
673
+ model = models.DescribeEmrOverviewMetricsRequest()
674
+ model.from_json_string(json.dumps(args))
675
+ start_time = time.time()
676
+ while True:
677
+ rsp = client.DescribeEmrOverviewMetrics(model)
678
+ result = rsp.to_json_string()
679
+ try:
680
+ json_obj = json.loads(result)
681
+ except TypeError as e:
682
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
683
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
684
+ break
685
+ cur_time = time.time()
686
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
687
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
688
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
689
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
690
+ else:
691
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
692
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
693
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
694
+
695
+
696
+ def doScaleOutInstance(args, parsed_globals):
697
+ g_param = parse_global_arg(parsed_globals)
698
+
699
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
700
+ cred = credential.CVMRoleCredential()
701
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
702
+ cred = credential.STSAssumeRoleCredential(
703
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
704
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
705
+ )
706
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
707
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
708
+ else:
709
+ cred = credential.Credential(
710
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
711
+ )
712
+ http_profile = HttpProfile(
713
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
714
+ reqMethod="POST",
715
+ endpoint=g_param[OptionsDefine.Endpoint],
716
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
717
+ )
718
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
719
+ if g_param[OptionsDefine.Language]:
720
+ profile.language = g_param[OptionsDefine.Language]
721
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
722
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
723
+ client._sdkVersion += ("_CLI_" + __version__)
724
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
725
+ model = models.ScaleOutInstanceRequest()
726
+ model.from_json_string(json.dumps(args))
727
+ start_time = time.time()
728
+ while True:
729
+ rsp = client.ScaleOutInstance(model)
730
+ result = rsp.to_json_string()
731
+ try:
732
+ json_obj = json.loads(result)
733
+ except TypeError as e:
734
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
735
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
736
+ break
737
+ cur_time = time.time()
738
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
739
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
740
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
741
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
742
+ else:
743
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
744
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
745
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
746
+
747
+
748
+ def doAttachDisks(args, parsed_globals):
749
+ g_param = parse_global_arg(parsed_globals)
750
+
751
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
752
+ cred = credential.CVMRoleCredential()
753
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
754
+ cred = credential.STSAssumeRoleCredential(
755
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
756
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
757
+ )
758
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
759
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
760
+ else:
761
+ cred = credential.Credential(
762
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
763
+ )
764
+ http_profile = HttpProfile(
765
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
766
+ reqMethod="POST",
767
+ endpoint=g_param[OptionsDefine.Endpoint],
768
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
769
+ )
770
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
771
+ if g_param[OptionsDefine.Language]:
772
+ profile.language = g_param[OptionsDefine.Language]
773
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
774
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
775
+ client._sdkVersion += ("_CLI_" + __version__)
776
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
777
+ model = models.AttachDisksRequest()
778
+ model.from_json_string(json.dumps(args))
779
+ start_time = time.time()
780
+ while True:
781
+ rsp = client.AttachDisks(model)
782
+ result = rsp.to_json_string()
783
+ try:
784
+ json_obj = json.loads(result)
785
+ except TypeError as e:
786
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
787
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
788
+ break
789
+ cur_time = time.time()
790
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
791
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
792
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
793
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
794
+ else:
795
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
796
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
797
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
798
+
799
+
800
+ def doSetNodeResourceConfigDefault(args, parsed_globals):
801
+ g_param = parse_global_arg(parsed_globals)
802
+
803
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
804
+ cred = credential.CVMRoleCredential()
805
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
806
+ cred = credential.STSAssumeRoleCredential(
807
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
808
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
809
+ )
810
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
811
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
812
+ else:
813
+ cred = credential.Credential(
814
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
815
+ )
816
+ http_profile = HttpProfile(
817
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
818
+ reqMethod="POST",
819
+ endpoint=g_param[OptionsDefine.Endpoint],
820
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
821
+ )
822
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
823
+ if g_param[OptionsDefine.Language]:
824
+ profile.language = g_param[OptionsDefine.Language]
825
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
826
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
827
+ client._sdkVersion += ("_CLI_" + __version__)
828
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
829
+ model = models.SetNodeResourceConfigDefaultRequest()
830
+ model.from_json_string(json.dumps(args))
831
+ start_time = time.time()
832
+ while True:
833
+ rsp = client.SetNodeResourceConfigDefault(model)
834
+ result = rsp.to_json_string()
835
+ try:
836
+ json_obj = json.loads(result)
837
+ except TypeError as e:
838
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
839
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
840
+ break
841
+ cur_time = time.time()
842
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
843
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
844
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
845
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
846
+ else:
847
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
848
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
849
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
850
+
851
+
852
+ def doDescribeStarRocksQueryInfo(args, parsed_globals):
853
+ g_param = parse_global_arg(parsed_globals)
854
+
855
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
856
+ cred = credential.CVMRoleCredential()
857
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
858
+ cred = credential.STSAssumeRoleCredential(
859
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
860
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
861
+ )
862
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
863
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
864
+ else:
865
+ cred = credential.Credential(
866
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
867
+ )
868
+ http_profile = HttpProfile(
869
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
870
+ reqMethod="POST",
871
+ endpoint=g_param[OptionsDefine.Endpoint],
872
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
873
+ )
874
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
875
+ if g_param[OptionsDefine.Language]:
876
+ profile.language = g_param[OptionsDefine.Language]
877
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
878
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
879
+ client._sdkVersion += ("_CLI_" + __version__)
880
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
881
+ model = models.DescribeStarRocksQueryInfoRequest()
882
+ model.from_json_string(json.dumps(args))
883
+ start_time = time.time()
884
+ while True:
885
+ rsp = client.DescribeStarRocksQueryInfo(model)
886
+ result = rsp.to_json_string()
887
+ try:
888
+ json_obj = json.loads(result)
889
+ except TypeError as e:
890
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
891
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
892
+ break
893
+ cur_time = time.time()
894
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
895
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
896
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
897
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
898
+ else:
899
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
900
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
901
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
902
+
903
+
904
+ def doModifySLInstanceBasic(args, parsed_globals):
905
+ g_param = parse_global_arg(parsed_globals)
906
+
907
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
908
+ cred = credential.CVMRoleCredential()
909
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
910
+ cred = credential.STSAssumeRoleCredential(
911
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
912
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
913
+ )
914
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
915
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
916
+ else:
917
+ cred = credential.Credential(
918
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
919
+ )
920
+ http_profile = HttpProfile(
921
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
922
+ reqMethod="POST",
923
+ endpoint=g_param[OptionsDefine.Endpoint],
924
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
925
+ )
926
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
927
+ if g_param[OptionsDefine.Language]:
928
+ profile.language = g_param[OptionsDefine.Language]
929
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
930
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
931
+ client._sdkVersion += ("_CLI_" + __version__)
932
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
933
+ model = models.ModifySLInstanceBasicRequest()
934
+ model.from_json_string(json.dumps(args))
935
+ start_time = time.time()
936
+ while True:
937
+ rsp = client.ModifySLInstanceBasic(model)
938
+ result = rsp.to_json_string()
939
+ try:
940
+ json_obj = json.loads(result)
941
+ except TypeError as e:
942
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
943
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
944
+ break
945
+ cur_time = time.time()
946
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
947
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
948
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
949
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
950
+ else:
951
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
952
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
953
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
954
+
955
+
956
+ def doAddMetricScaleStrategy(args, parsed_globals):
957
+ g_param = parse_global_arg(parsed_globals)
958
+
959
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
960
+ cred = credential.CVMRoleCredential()
961
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
962
+ cred = credential.STSAssumeRoleCredential(
963
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
964
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
965
+ )
966
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
967
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
968
+ else:
969
+ cred = credential.Credential(
970
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
971
+ )
972
+ http_profile = HttpProfile(
973
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
974
+ reqMethod="POST",
975
+ endpoint=g_param[OptionsDefine.Endpoint],
976
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
977
+ )
978
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
979
+ if g_param[OptionsDefine.Language]:
980
+ profile.language = g_param[OptionsDefine.Language]
981
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
982
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
983
+ client._sdkVersion += ("_CLI_" + __version__)
984
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
985
+ model = models.AddMetricScaleStrategyRequest()
986
+ model.from_json_string(json.dumps(args))
987
+ start_time = time.time()
988
+ while True:
989
+ rsp = client.AddMetricScaleStrategy(model)
990
+ result = rsp.to_json_string()
991
+ try:
992
+ json_obj = json.loads(result)
993
+ except TypeError as e:
994
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
995
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
996
+ break
997
+ cur_time = time.time()
998
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
999
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1000
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1001
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1002
+ else:
1003
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1004
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1005
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1006
+
1007
+
1008
+ def doDescribeServiceNodeInfos(args, parsed_globals):
1009
+ g_param = parse_global_arg(parsed_globals)
1010
+
1011
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1012
+ cred = credential.CVMRoleCredential()
1013
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1014
+ cred = credential.STSAssumeRoleCredential(
1015
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1016
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1017
+ )
1018
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1019
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1020
+ else:
1021
+ cred = credential.Credential(
1022
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1023
+ )
1024
+ http_profile = HttpProfile(
1025
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1026
+ reqMethod="POST",
1027
+ endpoint=g_param[OptionsDefine.Endpoint],
1028
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1029
+ )
1030
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1031
+ if g_param[OptionsDefine.Language]:
1032
+ profile.language = g_param[OptionsDefine.Language]
1033
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1034
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1035
+ client._sdkVersion += ("_CLI_" + __version__)
1036
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1037
+ model = models.DescribeServiceNodeInfosRequest()
1038
+ model.from_json_string(json.dumps(args))
1039
+ start_time = time.time()
1040
+ while True:
1041
+ rsp = client.DescribeServiceNodeInfos(model)
1042
+ result = rsp.to_json_string()
1043
+ try:
1044
+ json_obj = json.loads(result)
1045
+ except TypeError as e:
1046
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1047
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1048
+ break
1049
+ cur_time = time.time()
1050
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1051
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1052
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1053
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1054
+ else:
1055
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1056
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1057
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1058
+
1059
+
1060
+ def doDescribeInstances(args, parsed_globals):
1061
+ g_param = parse_global_arg(parsed_globals)
1062
+
1063
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1064
+ cred = credential.CVMRoleCredential()
1065
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1066
+ cred = credential.STSAssumeRoleCredential(
1067
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1068
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1069
+ )
1070
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1071
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1072
+ else:
1073
+ cred = credential.Credential(
1074
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1075
+ )
1076
+ http_profile = HttpProfile(
1077
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1078
+ reqMethod="POST",
1079
+ endpoint=g_param[OptionsDefine.Endpoint],
1080
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1081
+ )
1082
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1083
+ if g_param[OptionsDefine.Language]:
1084
+ profile.language = g_param[OptionsDefine.Language]
1085
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1086
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1087
+ client._sdkVersion += ("_CLI_" + __version__)
1088
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1089
+ model = models.DescribeInstancesRequest()
1090
+ model.from_json_string(json.dumps(args))
1091
+ start_time = time.time()
1092
+ while True:
1093
+ rsp = client.DescribeInstances(model)
1094
+ result = rsp.to_json_string()
1095
+ try:
1096
+ json_obj = json.loads(result)
1097
+ except TypeError as e:
1098
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1099
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1100
+ break
1101
+ cur_time = time.time()
1102
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1103
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1104
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1105
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1106
+ else:
1107
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1108
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1109
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1110
+
1111
+
1112
+ def doModifyYarnDeploy(args, parsed_globals):
1113
+ g_param = parse_global_arg(parsed_globals)
1114
+
1115
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1116
+ cred = credential.CVMRoleCredential()
1117
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1118
+ cred = credential.STSAssumeRoleCredential(
1119
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1120
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1121
+ )
1122
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1123
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1124
+ else:
1125
+ cred = credential.Credential(
1126
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1127
+ )
1128
+ http_profile = HttpProfile(
1129
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1130
+ reqMethod="POST",
1131
+ endpoint=g_param[OptionsDefine.Endpoint],
1132
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1133
+ )
1134
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1135
+ if g_param[OptionsDefine.Language]:
1136
+ profile.language = g_param[OptionsDefine.Language]
1137
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1138
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1139
+ client._sdkVersion += ("_CLI_" + __version__)
1140
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1141
+ model = models.ModifyYarnDeployRequest()
1142
+ model.from_json_string(json.dumps(args))
1143
+ start_time = time.time()
1144
+ while True:
1145
+ rsp = client.ModifyYarnDeploy(model)
1146
+ result = rsp.to_json_string()
1147
+ try:
1148
+ json_obj = json.loads(result)
1149
+ except TypeError as e:
1150
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1151
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1152
+ break
1153
+ cur_time = time.time()
1154
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1155
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1156
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1157
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1158
+ else:
1159
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1160
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1161
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1162
+
1163
+
1164
+ def doTerminateTasks(args, parsed_globals):
1165
+ g_param = parse_global_arg(parsed_globals)
1166
+
1167
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1168
+ cred = credential.CVMRoleCredential()
1169
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1170
+ cred = credential.STSAssumeRoleCredential(
1171
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1172
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1173
+ )
1174
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1175
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1176
+ else:
1177
+ cred = credential.Credential(
1178
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1179
+ )
1180
+ http_profile = HttpProfile(
1181
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1182
+ reqMethod="POST",
1183
+ endpoint=g_param[OptionsDefine.Endpoint],
1184
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1185
+ )
1186
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1187
+ if g_param[OptionsDefine.Language]:
1188
+ profile.language = g_param[OptionsDefine.Language]
1189
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1190
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1191
+ client._sdkVersion += ("_CLI_" + __version__)
1192
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1193
+ model = models.TerminateTasksRequest()
1194
+ model.from_json_string(json.dumps(args))
1195
+ start_time = time.time()
1196
+ while True:
1197
+ rsp = client.TerminateTasks(model)
1198
+ result = rsp.to_json_string()
1199
+ try:
1200
+ json_obj = json.loads(result)
1201
+ except TypeError as e:
1202
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1203
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1204
+ break
1205
+ cur_time = time.time()
1206
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1207
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1208
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1209
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1210
+ else:
1211
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1212
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1213
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1214
+
1215
+
1216
+ def doDeleteGroupsSTD(args, parsed_globals):
1217
+ g_param = parse_global_arg(parsed_globals)
1218
+
1219
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1220
+ cred = credential.CVMRoleCredential()
1221
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1222
+ cred = credential.STSAssumeRoleCredential(
1223
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1224
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1225
+ )
1226
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1227
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1228
+ else:
1229
+ cred = credential.Credential(
1230
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1231
+ )
1232
+ http_profile = HttpProfile(
1233
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1234
+ reqMethod="POST",
1235
+ endpoint=g_param[OptionsDefine.Endpoint],
1236
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1237
+ )
1238
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1239
+ if g_param[OptionsDefine.Language]:
1240
+ profile.language = g_param[OptionsDefine.Language]
1241
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1242
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1243
+ client._sdkVersion += ("_CLI_" + __version__)
1244
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1245
+ model = models.DeleteGroupsSTDRequest()
1246
+ model.from_json_string(json.dumps(args))
1247
+ start_time = time.time()
1248
+ while True:
1249
+ rsp = client.DeleteGroupsSTD(model)
1250
+ result = rsp.to_json_string()
1251
+ try:
1252
+ json_obj = json.loads(result)
1253
+ except TypeError as e:
1254
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1255
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1256
+ break
1257
+ cur_time = time.time()
1258
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1259
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1260
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1261
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1262
+ else:
1263
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1264
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1265
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1266
+
1267
+
1268
+ def doTerminateClusterNodes(args, parsed_globals):
1269
+ g_param = parse_global_arg(parsed_globals)
1270
+
1271
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1272
+ cred = credential.CVMRoleCredential()
1273
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1274
+ cred = credential.STSAssumeRoleCredential(
1275
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1276
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1277
+ )
1278
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1279
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1280
+ else:
1281
+ cred = credential.Credential(
1282
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1283
+ )
1284
+ http_profile = HttpProfile(
1285
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1286
+ reqMethod="POST",
1287
+ endpoint=g_param[OptionsDefine.Endpoint],
1288
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1289
+ )
1290
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1291
+ if g_param[OptionsDefine.Language]:
1292
+ profile.language = g_param[OptionsDefine.Language]
1293
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1294
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1295
+ client._sdkVersion += ("_CLI_" + __version__)
1296
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1297
+ model = models.TerminateClusterNodesRequest()
1298
+ model.from_json_string(json.dumps(args))
1299
+ start_time = time.time()
1300
+ while True:
1301
+ rsp = client.TerminateClusterNodes(model)
1302
+ result = rsp.to_json_string()
1303
+ try:
1304
+ json_obj = json.loads(result)
1305
+ except TypeError as e:
1306
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1307
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1308
+ break
1309
+ cur_time = time.time()
1310
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1311
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1312
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1313
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1314
+ else:
1315
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1316
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1317
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1318
+
1319
+
1320
+ def doResetYarnConfig(args, parsed_globals):
1321
+ g_param = parse_global_arg(parsed_globals)
1322
+
1323
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1324
+ cred = credential.CVMRoleCredential()
1325
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1326
+ cred = credential.STSAssumeRoleCredential(
1327
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1328
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1329
+ )
1330
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1331
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1332
+ else:
1333
+ cred = credential.Credential(
1334
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1335
+ )
1336
+ http_profile = HttpProfile(
1337
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1338
+ reqMethod="POST",
1339
+ endpoint=g_param[OptionsDefine.Endpoint],
1340
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1341
+ )
1342
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1343
+ if g_param[OptionsDefine.Language]:
1344
+ profile.language = g_param[OptionsDefine.Language]
1345
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1346
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1347
+ client._sdkVersion += ("_CLI_" + __version__)
1348
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1349
+ model = models.ResetYarnConfigRequest()
1350
+ model.from_json_string(json.dumps(args))
1351
+ start_time = time.time()
1352
+ while True:
1353
+ rsp = client.ResetYarnConfig(model)
1354
+ result = rsp.to_json_string()
1355
+ try:
1356
+ json_obj = json.loads(result)
1357
+ except TypeError as e:
1358
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1359
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1360
+ break
1361
+ cur_time = time.time()
1362
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1363
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1364
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1365
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1366
+ else:
1367
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1368
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1369
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1370
+
1371
+
1372
+ def doDescribeUsersForUserManager(args, parsed_globals):
1373
+ g_param = parse_global_arg(parsed_globals)
1374
+
1375
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1376
+ cred = credential.CVMRoleCredential()
1377
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1378
+ cred = credential.STSAssumeRoleCredential(
1379
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1380
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1381
+ )
1382
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1383
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1384
+ else:
1385
+ cred = credential.Credential(
1386
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1387
+ )
1388
+ http_profile = HttpProfile(
1389
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1390
+ reqMethod="POST",
1391
+ endpoint=g_param[OptionsDefine.Endpoint],
1392
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1393
+ )
1394
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1395
+ if g_param[OptionsDefine.Language]:
1396
+ profile.language = g_param[OptionsDefine.Language]
1397
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1398
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1399
+ client._sdkVersion += ("_CLI_" + __version__)
1400
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1401
+ model = models.DescribeUsersForUserManagerRequest()
1402
+ model.from_json_string(json.dumps(args))
1403
+ start_time = time.time()
1404
+ while True:
1405
+ rsp = client.DescribeUsersForUserManager(model)
1406
+ result = rsp.to_json_string()
1407
+ try:
1408
+ json_obj = json.loads(result)
1409
+ except TypeError as e:
1410
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1411
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1412
+ break
1413
+ cur_time = time.time()
1414
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1415
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1416
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1417
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1418
+ else:
1419
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1420
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1421
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1422
+
1423
+
1424
+ def doModifyUserManagerPwd(args, parsed_globals):
1425
+ g_param = parse_global_arg(parsed_globals)
1426
+
1427
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1428
+ cred = credential.CVMRoleCredential()
1429
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1430
+ cred = credential.STSAssumeRoleCredential(
1431
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1432
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1433
+ )
1434
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1435
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1436
+ else:
1437
+ cred = credential.Credential(
1438
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1439
+ )
1440
+ http_profile = HttpProfile(
1441
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1442
+ reqMethod="POST",
1443
+ endpoint=g_param[OptionsDefine.Endpoint],
1444
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1445
+ )
1446
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1447
+ if g_param[OptionsDefine.Language]:
1448
+ profile.language = g_param[OptionsDefine.Language]
1449
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1450
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1451
+ client._sdkVersion += ("_CLI_" + __version__)
1452
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1453
+ model = models.ModifyUserManagerPwdRequest()
1454
+ model.from_json_string(json.dumps(args))
1455
+ start_time = time.time()
1456
+ while True:
1457
+ rsp = client.ModifyUserManagerPwd(model)
1458
+ result = rsp.to_json_string()
1459
+ try:
1460
+ json_obj = json.loads(result)
1461
+ except TypeError as e:
1462
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1463
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1464
+ break
1465
+ cur_time = time.time()
1466
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1467
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1468
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1469
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1470
+ else:
1471
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1472
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1473
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1474
+
1475
+
1476
+ def doConvertPreToPostCluster(args, parsed_globals):
1477
+ g_param = parse_global_arg(parsed_globals)
1478
+
1479
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1480
+ cred = credential.CVMRoleCredential()
1481
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1482
+ cred = credential.STSAssumeRoleCredential(
1483
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1484
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1485
+ )
1486
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1487
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1488
+ else:
1489
+ cred = credential.Credential(
1490
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1491
+ )
1492
+ http_profile = HttpProfile(
1493
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1494
+ reqMethod="POST",
1495
+ endpoint=g_param[OptionsDefine.Endpoint],
1496
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1497
+ )
1498
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1499
+ if g_param[OptionsDefine.Language]:
1500
+ profile.language = g_param[OptionsDefine.Language]
1501
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1502
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1503
+ client._sdkVersion += ("_CLI_" + __version__)
1504
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1505
+ model = models.ConvertPreToPostClusterRequest()
1506
+ model.from_json_string(json.dumps(args))
1507
+ start_time = time.time()
1508
+ while True:
1509
+ rsp = client.ConvertPreToPostCluster(model)
1510
+ result = rsp.to_json_string()
1511
+ try:
1512
+ json_obj = json.loads(result)
1513
+ except TypeError as e:
1514
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1515
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1516
+ break
1517
+ cur_time = time.time()
1518
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1519
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1520
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1521
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1522
+ else:
1523
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1524
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1525
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1526
+
1527
+
1528
+ def doCreateGroupsSTD(args, parsed_globals):
1529
+ g_param = parse_global_arg(parsed_globals)
1530
+
1531
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1532
+ cred = credential.CVMRoleCredential()
1533
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1534
+ cred = credential.STSAssumeRoleCredential(
1535
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1536
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1537
+ )
1538
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1539
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1540
+ else:
1541
+ cred = credential.Credential(
1542
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1543
+ )
1544
+ http_profile = HttpProfile(
1545
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1546
+ reqMethod="POST",
1547
+ endpoint=g_param[OptionsDefine.Endpoint],
1548
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1549
+ )
1550
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1551
+ if g_param[OptionsDefine.Language]:
1552
+ profile.language = g_param[OptionsDefine.Language]
1553
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1554
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1555
+ client._sdkVersion += ("_CLI_" + __version__)
1556
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1557
+ model = models.CreateGroupsSTDRequest()
1558
+ model.from_json_string(json.dumps(args))
1559
+ start_time = time.time()
1560
+ while True:
1561
+ rsp = client.CreateGroupsSTD(model)
1562
+ result = rsp.to_json_string()
1563
+ try:
1564
+ json_obj = json.loads(result)
1565
+ except TypeError as e:
1566
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1567
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1568
+ break
1569
+ cur_time = time.time()
1570
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1571
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1572
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1573
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1574
+ else:
1575
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1576
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1577
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1578
+
1579
+
1580
+ def doTerminateSLInstance(args, parsed_globals):
1581
+ g_param = parse_global_arg(parsed_globals)
1582
+
1583
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1584
+ cred = credential.CVMRoleCredential()
1585
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1586
+ cred = credential.STSAssumeRoleCredential(
1587
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1588
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1589
+ )
1590
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1591
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1592
+ else:
1593
+ cred = credential.Credential(
1594
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1595
+ )
1596
+ http_profile = HttpProfile(
1597
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1598
+ reqMethod="POST",
1599
+ endpoint=g_param[OptionsDefine.Endpoint],
1600
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1601
+ )
1602
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1603
+ if g_param[OptionsDefine.Language]:
1604
+ profile.language = g_param[OptionsDefine.Language]
1605
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1606
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1607
+ client._sdkVersion += ("_CLI_" + __version__)
1608
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1609
+ model = models.TerminateSLInstanceRequest()
1610
+ model.from_json_string(json.dumps(args))
1611
+ start_time = time.time()
1612
+ while True:
1613
+ rsp = client.TerminateSLInstance(model)
1614
+ result = rsp.to_json_string()
1615
+ try:
1616
+ json_obj = json.loads(result)
1617
+ except TypeError as e:
1618
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1619
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1620
+ break
1621
+ cur_time = time.time()
1622
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1623
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1624
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1625
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1626
+ else:
1627
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1628
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1629
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1630
+
1631
+
1632
+ def doAddUsersForUserManager(args, parsed_globals):
1633
+ g_param = parse_global_arg(parsed_globals)
1634
+
1635
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1636
+ cred = credential.CVMRoleCredential()
1637
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1638
+ cred = credential.STSAssumeRoleCredential(
1639
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1640
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1641
+ )
1642
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1643
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1644
+ else:
1645
+ cred = credential.Credential(
1646
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1647
+ )
1648
+ http_profile = HttpProfile(
1649
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1650
+ reqMethod="POST",
1651
+ endpoint=g_param[OptionsDefine.Endpoint],
1652
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1653
+ )
1654
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1655
+ if g_param[OptionsDefine.Language]:
1656
+ profile.language = g_param[OptionsDefine.Language]
1657
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1658
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1659
+ client._sdkVersion += ("_CLI_" + __version__)
1660
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1661
+ model = models.AddUsersForUserManagerRequest()
1662
+ model.from_json_string(json.dumps(args))
1663
+ start_time = time.time()
1664
+ while True:
1665
+ rsp = client.AddUsersForUserManager(model)
1666
+ result = rsp.to_json_string()
1667
+ try:
1668
+ json_obj = json.loads(result)
1669
+ except TypeError as e:
1670
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1671
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1672
+ break
1673
+ cur_time = time.time()
1674
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1675
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1676
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1677
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1678
+ else:
1679
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1680
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1681
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1682
+
1683
+
1684
+ def doDescribeSparkApplications(args, parsed_globals):
1685
+ g_param = parse_global_arg(parsed_globals)
1686
+
1687
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1688
+ cred = credential.CVMRoleCredential()
1689
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1690
+ cred = credential.STSAssumeRoleCredential(
1691
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1692
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1693
+ )
1694
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1695
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1696
+ else:
1697
+ cred = credential.Credential(
1698
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1699
+ )
1700
+ http_profile = HttpProfile(
1701
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1702
+ reqMethod="POST",
1703
+ endpoint=g_param[OptionsDefine.Endpoint],
1704
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1705
+ )
1706
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1707
+ if g_param[OptionsDefine.Language]:
1708
+ profile.language = g_param[OptionsDefine.Language]
1709
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1710
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1711
+ client._sdkVersion += ("_CLI_" + __version__)
1712
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1713
+ model = models.DescribeSparkApplicationsRequest()
1714
+ model.from_json_string(json.dumps(args))
1715
+ start_time = time.time()
1716
+ while True:
1717
+ rsp = client.DescribeSparkApplications(model)
1718
+ result = rsp.to_json_string()
1719
+ try:
1720
+ json_obj = json.loads(result)
1721
+ except TypeError as e:
1722
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1723
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1724
+ break
1725
+ cur_time = time.time()
1726
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1727
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1728
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1729
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1730
+ else:
1731
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1732
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1733
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1734
+
1735
+
1736
+ def doModifyUserGroup(args, parsed_globals):
1737
+ g_param = parse_global_arg(parsed_globals)
1738
+
1739
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1740
+ cred = credential.CVMRoleCredential()
1741
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1742
+ cred = credential.STSAssumeRoleCredential(
1743
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1744
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1745
+ )
1746
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1747
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1748
+ else:
1749
+ cred = credential.Credential(
1750
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1751
+ )
1752
+ http_profile = HttpProfile(
1753
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1754
+ reqMethod="POST",
1755
+ endpoint=g_param[OptionsDefine.Endpoint],
1756
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1757
+ )
1758
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1759
+ if g_param[OptionsDefine.Language]:
1760
+ profile.language = g_param[OptionsDefine.Language]
1761
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1762
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1763
+ client._sdkVersion += ("_CLI_" + __version__)
1764
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1765
+ model = models.ModifyUserGroupRequest()
1766
+ model.from_json_string(json.dumps(args))
1767
+ start_time = time.time()
1768
+ while True:
1769
+ rsp = client.ModifyUserGroup(model)
1770
+ result = rsp.to_json_string()
1771
+ try:
1772
+ json_obj = json.loads(result)
1773
+ except TypeError as e:
1774
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1775
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1776
+ break
1777
+ cur_time = time.time()
1778
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1779
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1780
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1781
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1782
+ else:
1783
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1784
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1785
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1786
+
1787
+
1788
+ def doCreateSLInstance(args, parsed_globals):
1789
+ g_param = parse_global_arg(parsed_globals)
1790
+
1791
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1792
+ cred = credential.CVMRoleCredential()
1793
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1794
+ cred = credential.STSAssumeRoleCredential(
1795
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1796
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1797
+ )
1798
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1799
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1800
+ else:
1801
+ cred = credential.Credential(
1802
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1803
+ )
1804
+ http_profile = HttpProfile(
1805
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1806
+ reqMethod="POST",
1807
+ endpoint=g_param[OptionsDefine.Endpoint],
1808
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1809
+ )
1810
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1811
+ if g_param[OptionsDefine.Language]:
1812
+ profile.language = g_param[OptionsDefine.Language]
1813
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1814
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1815
+ client._sdkVersion += ("_CLI_" + __version__)
1816
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1817
+ model = models.CreateSLInstanceRequest()
1818
+ model.from_json_string(json.dumps(args))
1819
+ start_time = time.time()
1820
+ while True:
1821
+ rsp = client.CreateSLInstance(model)
1822
+ result = rsp.to_json_string()
1823
+ try:
1824
+ json_obj = json.loads(result)
1825
+ except TypeError as e:
1826
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1827
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1828
+ break
1829
+ cur_time = time.time()
1830
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1831
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1832
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1833
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1834
+ else:
1835
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1836
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1837
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1838
+
1839
+
1840
+ def doDescribeSLInstanceList(args, parsed_globals):
1841
+ g_param = parse_global_arg(parsed_globals)
1842
+
1843
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1844
+ cred = credential.CVMRoleCredential()
1845
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1846
+ cred = credential.STSAssumeRoleCredential(
1847
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1848
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1849
+ )
1850
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1851
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1852
+ else:
1853
+ cred = credential.Credential(
1854
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1855
+ )
1856
+ http_profile = HttpProfile(
1857
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1858
+ reqMethod="POST",
1859
+ endpoint=g_param[OptionsDefine.Endpoint],
1860
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1861
+ )
1862
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1863
+ if g_param[OptionsDefine.Language]:
1864
+ profile.language = g_param[OptionsDefine.Language]
1865
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1866
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1867
+ client._sdkVersion += ("_CLI_" + __version__)
1868
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1869
+ model = models.DescribeSLInstanceListRequest()
1870
+ model.from_json_string(json.dumps(args))
1871
+ start_time = time.time()
1872
+ while True:
1873
+ rsp = client.DescribeSLInstanceList(model)
1874
+ result = rsp.to_json_string()
1875
+ try:
1876
+ json_obj = json.loads(result)
1877
+ except TypeError as e:
1878
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1879
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1880
+ break
1881
+ cur_time = time.time()
1882
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1883
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1884
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1885
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1886
+ else:
1887
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1888
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1889
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1890
+
1891
+
1892
+ def doAddNodeResourceConfig(args, parsed_globals):
1893
+ g_param = parse_global_arg(parsed_globals)
1894
+
1895
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1896
+ cred = credential.CVMRoleCredential()
1897
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1898
+ cred = credential.STSAssumeRoleCredential(
1899
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1900
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1901
+ )
1902
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1903
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1904
+ else:
1905
+ cred = credential.Credential(
1906
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1907
+ )
1908
+ http_profile = HttpProfile(
1909
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1910
+ reqMethod="POST",
1911
+ endpoint=g_param[OptionsDefine.Endpoint],
1912
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1913
+ )
1914
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1915
+ if g_param[OptionsDefine.Language]:
1916
+ profile.language = g_param[OptionsDefine.Language]
1917
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1918
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1919
+ client._sdkVersion += ("_CLI_" + __version__)
1920
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1921
+ model = models.AddNodeResourceConfigRequest()
1922
+ model.from_json_string(json.dumps(args))
1923
+ start_time = time.time()
1924
+ while True:
1925
+ rsp = client.AddNodeResourceConfig(model)
1926
+ result = rsp.to_json_string()
1927
+ try:
1928
+ json_obj = json.loads(result)
1929
+ except TypeError as e:
1930
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1931
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1932
+ break
1933
+ cur_time = time.time()
1934
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1935
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1936
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1937
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1938
+ else:
1939
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1940
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1941
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1942
+
1943
+
1944
+ def doModifyAutoScaleStrategy(args, parsed_globals):
1945
+ g_param = parse_global_arg(parsed_globals)
1946
+
1947
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
1948
+ cred = credential.CVMRoleCredential()
1949
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
1950
+ cred = credential.STSAssumeRoleCredential(
1951
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
1952
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
1953
+ )
1954
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
1955
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
1956
+ else:
1957
+ cred = credential.Credential(
1958
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
1959
+ )
1960
+ http_profile = HttpProfile(
1961
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
1962
+ reqMethod="POST",
1963
+ endpoint=g_param[OptionsDefine.Endpoint],
1964
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
1965
+ )
1966
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
1967
+ if g_param[OptionsDefine.Language]:
1968
+ profile.language = g_param[OptionsDefine.Language]
1969
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
1970
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1971
+ client._sdkVersion += ("_CLI_" + __version__)
1972
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
1973
+ model = models.ModifyAutoScaleStrategyRequest()
1974
+ model.from_json_string(json.dumps(args))
1975
+ start_time = time.time()
1976
+ while True:
1977
+ rsp = client.ModifyAutoScaleStrategy(model)
1978
+ result = rsp.to_json_string()
1979
+ try:
1980
+ json_obj = json.loads(result)
1981
+ except TypeError as e:
1982
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
1983
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
1984
+ break
1985
+ cur_time = time.time()
1986
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
1987
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
1988
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
1989
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
1990
+ else:
1991
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
1992
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
1993
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1994
+
1995
+
1996
+ def doDescribeKyuubiQueryInfo(args, parsed_globals):
1997
+ g_param = parse_global_arg(parsed_globals)
1998
+
1999
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2000
+ cred = credential.CVMRoleCredential()
2001
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2002
+ cred = credential.STSAssumeRoleCredential(
2003
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2004
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2005
+ )
2006
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2007
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2008
+ else:
2009
+ cred = credential.Credential(
2010
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2011
+ )
2012
+ http_profile = HttpProfile(
2013
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2014
+ reqMethod="POST",
2015
+ endpoint=g_param[OptionsDefine.Endpoint],
2016
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2017
+ )
2018
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2019
+ if g_param[OptionsDefine.Language]:
2020
+ profile.language = g_param[OptionsDefine.Language]
2021
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2022
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2023
+ client._sdkVersion += ("_CLI_" + __version__)
2024
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2025
+ model = models.DescribeKyuubiQueryInfoRequest()
2026
+ model.from_json_string(json.dumps(args))
2027
+ start_time = time.time()
2028
+ while True:
2029
+ rsp = client.DescribeKyuubiQueryInfo(model)
2030
+ result = rsp.to_json_string()
2031
+ try:
2032
+ json_obj = json.loads(result)
2033
+ except TypeError as e:
2034
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2035
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2036
+ break
2037
+ cur_time = time.time()
2038
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2039
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2040
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2041
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2042
+ else:
2043
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2044
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2045
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2046
+
2047
+
2048
+ def doDeleteAutoScaleStrategy(args, parsed_globals):
2049
+ g_param = parse_global_arg(parsed_globals)
2050
+
2051
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2052
+ cred = credential.CVMRoleCredential()
2053
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2054
+ cred = credential.STSAssumeRoleCredential(
2055
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2056
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2057
+ )
2058
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2059
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2060
+ else:
2061
+ cred = credential.Credential(
2062
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2063
+ )
2064
+ http_profile = HttpProfile(
2065
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2066
+ reqMethod="POST",
2067
+ endpoint=g_param[OptionsDefine.Endpoint],
2068
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2069
+ )
2070
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2071
+ if g_param[OptionsDefine.Language]:
2072
+ profile.language = g_param[OptionsDefine.Language]
2073
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2074
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2075
+ client._sdkVersion += ("_CLI_" + __version__)
2076
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2077
+ model = models.DeleteAutoScaleStrategyRequest()
2078
+ model.from_json_string(json.dumps(args))
2079
+ start_time = time.time()
2080
+ while True:
2081
+ rsp = client.DeleteAutoScaleStrategy(model)
2082
+ result = rsp.to_json_string()
2083
+ try:
2084
+ json_obj = json.loads(result)
2085
+ except TypeError as e:
2086
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2087
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2088
+ break
2089
+ cur_time = time.time()
2090
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2091
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2092
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2093
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2094
+ else:
2095
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2096
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2097
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2098
+
2099
+
2100
+ def doDescribeEmrApplicationStatics(args, parsed_globals):
2101
+ g_param = parse_global_arg(parsed_globals)
2102
+
2103
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2104
+ cred = credential.CVMRoleCredential()
2105
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2106
+ cred = credential.STSAssumeRoleCredential(
2107
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2108
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2109
+ )
2110
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2111
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2112
+ else:
2113
+ cred = credential.Credential(
2114
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2115
+ )
2116
+ http_profile = HttpProfile(
2117
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2118
+ reqMethod="POST",
2119
+ endpoint=g_param[OptionsDefine.Endpoint],
2120
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2121
+ )
2122
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2123
+ if g_param[OptionsDefine.Language]:
2124
+ profile.language = g_param[OptionsDefine.Language]
2125
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2126
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2127
+ client._sdkVersion += ("_CLI_" + __version__)
2128
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2129
+ model = models.DescribeEmrApplicationStaticsRequest()
2130
+ model.from_json_string(json.dumps(args))
2131
+ start_time = time.time()
2132
+ while True:
2133
+ rsp = client.DescribeEmrApplicationStatics(model)
2134
+ result = rsp.to_json_string()
2135
+ try:
2136
+ json_obj = json.loads(result)
2137
+ except TypeError as e:
2138
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2139
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2140
+ break
2141
+ cur_time = time.time()
2142
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2143
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2144
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2145
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2146
+ else:
2147
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2148
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2149
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2150
+
2151
+
2152
+ def doDescribeHDFSStorageInfo(args, parsed_globals):
2153
+ g_param = parse_global_arg(parsed_globals)
2154
+
2155
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2156
+ cred = credential.CVMRoleCredential()
2157
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2158
+ cred = credential.STSAssumeRoleCredential(
2159
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2160
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2161
+ )
2162
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2163
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2164
+ else:
2165
+ cred = credential.Credential(
2166
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2167
+ )
2168
+ http_profile = HttpProfile(
2169
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2170
+ reqMethod="POST",
2171
+ endpoint=g_param[OptionsDefine.Endpoint],
2172
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2173
+ )
2174
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2175
+ if g_param[OptionsDefine.Language]:
2176
+ profile.language = g_param[OptionsDefine.Language]
2177
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2178
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2179
+ client._sdkVersion += ("_CLI_" + __version__)
2180
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2181
+ model = models.DescribeHDFSStorageInfoRequest()
2182
+ model.from_json_string(json.dumps(args))
2183
+ start_time = time.time()
2184
+ while True:
2185
+ rsp = client.DescribeHDFSStorageInfo(model)
2186
+ result = rsp.to_json_string()
2187
+ try:
2188
+ json_obj = json.loads(result)
2189
+ except TypeError as e:
2190
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2191
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2192
+ break
2193
+ cur_time = time.time()
2194
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2195
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2196
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2197
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2198
+ else:
2199
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2200
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2201
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2202
+
2203
+
2204
+ def doCreateInstance(args, parsed_globals):
2205
+ g_param = parse_global_arg(parsed_globals)
2206
+
2207
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2208
+ cred = credential.CVMRoleCredential()
2209
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2210
+ cred = credential.STSAssumeRoleCredential(
2211
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2212
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2213
+ )
2214
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2215
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2216
+ else:
2217
+ cred = credential.Credential(
2218
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2219
+ )
2220
+ http_profile = HttpProfile(
2221
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2222
+ reqMethod="POST",
2223
+ endpoint=g_param[OptionsDefine.Endpoint],
2224
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2225
+ )
2226
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2227
+ if g_param[OptionsDefine.Language]:
2228
+ profile.language = g_param[OptionsDefine.Language]
2229
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2230
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2231
+ client._sdkVersion += ("_CLI_" + __version__)
2232
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2233
+ model = models.CreateInstanceRequest()
2234
+ model.from_json_string(json.dumps(args))
2235
+ start_time = time.time()
2236
+ while True:
2237
+ rsp = client.CreateInstance(model)
2238
+ result = rsp.to_json_string()
2239
+ try:
2240
+ json_obj = json.loads(result)
2241
+ except TypeError as e:
2242
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2243
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2244
+ break
2245
+ cur_time = time.time()
2246
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2247
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2248
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2249
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2250
+ else:
2251
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2252
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2253
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2254
+
2255
+
2256
+ def doModifyResourceScheduler(args, parsed_globals):
2257
+ g_param = parse_global_arg(parsed_globals)
2258
+
2259
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2260
+ cred = credential.CVMRoleCredential()
2261
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2262
+ cred = credential.STSAssumeRoleCredential(
2263
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2264
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2265
+ )
2266
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2267
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2268
+ else:
2269
+ cred = credential.Credential(
2270
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2271
+ )
2272
+ http_profile = HttpProfile(
2273
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2274
+ reqMethod="POST",
2275
+ endpoint=g_param[OptionsDefine.Endpoint],
2276
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2277
+ )
2278
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2279
+ if g_param[OptionsDefine.Language]:
2280
+ profile.language = g_param[OptionsDefine.Language]
2281
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2282
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2283
+ client._sdkVersion += ("_CLI_" + __version__)
2284
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2285
+ model = models.ModifyResourceSchedulerRequest()
2286
+ model.from_json_string(json.dumps(args))
2287
+ start_time = time.time()
2288
+ while True:
2289
+ rsp = client.ModifyResourceScheduler(model)
2290
+ result = rsp.to_json_string()
2291
+ try:
2292
+ json_obj = json.loads(result)
2293
+ except TypeError as e:
2294
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2295
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2296
+ break
2297
+ cur_time = time.time()
2298
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2299
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2300
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2301
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2302
+ else:
2303
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2304
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2305
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2306
+
2307
+
2308
+ def doDescribeHBaseTableOverview(args, parsed_globals):
2309
+ g_param = parse_global_arg(parsed_globals)
2310
+
2311
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2312
+ cred = credential.CVMRoleCredential()
2313
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2314
+ cred = credential.STSAssumeRoleCredential(
2315
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2316
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2317
+ )
2318
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2319
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2320
+ else:
2321
+ cred = credential.Credential(
2322
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2323
+ )
2324
+ http_profile = HttpProfile(
2325
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2326
+ reqMethod="POST",
2327
+ endpoint=g_param[OptionsDefine.Endpoint],
2328
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2329
+ )
2330
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2331
+ if g_param[OptionsDefine.Language]:
2332
+ profile.language = g_param[OptionsDefine.Language]
2333
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2334
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2335
+ client._sdkVersion += ("_CLI_" + __version__)
2336
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2337
+ model = models.DescribeHBaseTableOverviewRequest()
2338
+ model.from_json_string(json.dumps(args))
2339
+ start_time = time.time()
2340
+ while True:
2341
+ rsp = client.DescribeHBaseTableOverview(model)
2342
+ result = rsp.to_json_string()
2343
+ try:
2344
+ json_obj = json.loads(result)
2345
+ except TypeError as e:
2346
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2347
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2348
+ break
2349
+ cur_time = time.time()
2350
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2351
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2352
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2353
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2354
+ else:
2355
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2356
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2357
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2358
+
2359
+
2360
+ def doDescribeResourceScheduleDiffDetail(args, parsed_globals):
2361
+ g_param = parse_global_arg(parsed_globals)
2362
+
2363
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2364
+ cred = credential.CVMRoleCredential()
2365
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2366
+ cred = credential.STSAssumeRoleCredential(
2367
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2368
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2369
+ )
2370
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2371
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2372
+ else:
2373
+ cred = credential.Credential(
2374
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2375
+ )
2376
+ http_profile = HttpProfile(
2377
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2378
+ reqMethod="POST",
2379
+ endpoint=g_param[OptionsDefine.Endpoint],
2380
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2381
+ )
2382
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2383
+ if g_param[OptionsDefine.Language]:
2384
+ profile.language = g_param[OptionsDefine.Language]
2385
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2386
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2387
+ client._sdkVersion += ("_CLI_" + __version__)
2388
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2389
+ model = models.DescribeResourceScheduleDiffDetailRequest()
2390
+ model.from_json_string(json.dumps(args))
2391
+ start_time = time.time()
2392
+ while True:
2393
+ rsp = client.DescribeResourceScheduleDiffDetail(model)
2394
+ result = rsp.to_json_string()
2395
+ try:
2396
+ json_obj = json.loads(result)
2397
+ except TypeError as e:
2398
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2399
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2400
+ break
2401
+ cur_time = time.time()
2402
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2403
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2404
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2405
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2406
+ else:
2407
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2408
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2409
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2410
+
2411
+
2412
+ def doDescribeSLInstance(args, parsed_globals):
2413
+ g_param = parse_global_arg(parsed_globals)
2414
+
2415
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2416
+ cred = credential.CVMRoleCredential()
2417
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2418
+ cred = credential.STSAssumeRoleCredential(
2419
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2420
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2421
+ )
2422
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2423
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2424
+ else:
2425
+ cred = credential.Credential(
2426
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2427
+ )
2428
+ http_profile = HttpProfile(
2429
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2430
+ reqMethod="POST",
2431
+ endpoint=g_param[OptionsDefine.Endpoint],
2432
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2433
+ )
2434
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2435
+ if g_param[OptionsDefine.Language]:
2436
+ profile.language = g_param[OptionsDefine.Language]
2437
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2438
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2439
+ client._sdkVersion += ("_CLI_" + __version__)
2440
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2441
+ model = models.DescribeSLInstanceRequest()
2442
+ model.from_json_string(json.dumps(args))
2443
+ start_time = time.time()
2444
+ while True:
2445
+ rsp = client.DescribeSLInstance(model)
2446
+ result = rsp.to_json_string()
2447
+ try:
2448
+ json_obj = json.loads(result)
2449
+ except TypeError as e:
2450
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
2451
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
2452
+ break
2453
+ cur_time = time.time()
2454
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
2455
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
2456
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
2457
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
2458
+ else:
2459
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
2460
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
2461
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2462
+
2463
+
2464
+ def doDescribeSparkQueries(args, parsed_globals):
2465
+ g_param = parse_global_arg(parsed_globals)
2466
+
2467
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
2468
+ cred = credential.CVMRoleCredential()
2469
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
2470
+ cred = credential.STSAssumeRoleCredential(
2471
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
2472
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
2473
+ )
2474
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
2475
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
2476
+ else:
2477
+ cred = credential.Credential(
2478
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
2479
+ )
2480
+ http_profile = HttpProfile(
2481
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
2482
+ reqMethod="POST",
2483
+ endpoint=g_param[OptionsDefine.Endpoint],
2484
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
2485
+ )
2486
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
2487
+ if g_param[OptionsDefine.Language]:
2488
+ profile.language = g_param[OptionsDefine.Language]
2489
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
2490
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
2491
+ client._sdkVersion += ("_CLI_" + __version__)
2492
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
2493
+ model = models.DescribeSparkQueriesRequest()
206
2494
  model.from_json_string(json.dumps(args))
207
2495
  start_time = time.time()
208
2496
  while True:
209
- rsp = client.InquiryPriceRenewInstance(model)
2497
+ rsp = client.DescribeSparkQueries(model)
210
2498
  result = rsp.to_json_string()
211
2499
  try:
212
2500
  json_obj = json.loads(result)
@@ -225,7 +2513,7 @@ def doInquiryPriceRenewInstance(args, parsed_globals):
225
2513
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
226
2514
 
227
2515
 
228
- def doInquiryPriceScaleOutInstance(args, parsed_globals):
2516
+ def doModifyAutoRenewFlag(args, parsed_globals):
229
2517
  g_param = parse_global_arg(parsed_globals)
230
2518
 
231
2519
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -254,11 +2542,11 @@ def doInquiryPriceScaleOutInstance(args, parsed_globals):
254
2542
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
255
2543
  client._sdkVersion += ("_CLI_" + __version__)
256
2544
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
257
- model = models.InquiryPriceScaleOutInstanceRequest()
2545
+ model = models.ModifyAutoRenewFlagRequest()
258
2546
  model.from_json_string(json.dumps(args))
259
2547
  start_time = time.time()
260
2548
  while True:
261
- rsp = client.InquiryPriceScaleOutInstance(model)
2549
+ rsp = client.ModifyAutoRenewFlag(model)
262
2550
  result = rsp.to_json_string()
263
2551
  try:
264
2552
  json_obj = json.loads(result)
@@ -277,7 +2565,7 @@ def doInquiryPriceScaleOutInstance(args, parsed_globals):
277
2565
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
278
2566
 
279
2567
 
280
- def doDescribeAutoScaleRecords(args, parsed_globals):
2568
+ def doModifyResource(args, parsed_globals):
281
2569
  g_param = parse_global_arg(parsed_globals)
282
2570
 
283
2571
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -306,11 +2594,11 @@ def doDescribeAutoScaleRecords(args, parsed_globals):
306
2594
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
307
2595
  client._sdkVersion += ("_CLI_" + __version__)
308
2596
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
309
- model = models.DescribeAutoScaleRecordsRequest()
2597
+ model = models.ModifyResourceRequest()
310
2598
  model.from_json_string(json.dumps(args))
311
2599
  start_time = time.time()
312
2600
  while True:
313
- rsp = client.DescribeAutoScaleRecords(model)
2601
+ rsp = client.ModifyResource(model)
314
2602
  result = rsp.to_json_string()
315
2603
  try:
316
2604
  json_obj = json.loads(result)
@@ -329,7 +2617,7 @@ def doDescribeAutoScaleRecords(args, parsed_globals):
329
2617
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
330
2618
 
331
2619
 
332
- def doScaleOutInstance(args, parsed_globals):
2620
+ def doInquiryPriceCreateInstance(args, parsed_globals):
333
2621
  g_param = parse_global_arg(parsed_globals)
334
2622
 
335
2623
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -358,11 +2646,11 @@ def doScaleOutInstance(args, parsed_globals):
358
2646
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
359
2647
  client._sdkVersion += ("_CLI_" + __version__)
360
2648
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
361
- model = models.ScaleOutInstanceRequest()
2649
+ model = models.InquiryPriceCreateInstanceRequest()
362
2650
  model.from_json_string(json.dumps(args))
363
2651
  start_time = time.time()
364
2652
  while True:
365
- rsp = client.ScaleOutInstance(model)
2653
+ rsp = client.InquiryPriceCreateInstance(model)
366
2654
  result = rsp.to_json_string()
367
2655
  try:
368
2656
  json_obj = json.loads(result)
@@ -381,7 +2669,7 @@ def doScaleOutInstance(args, parsed_globals):
381
2669
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
382
2670
 
383
2671
 
384
- def doModifyUserManagerPwd(args, parsed_globals):
2672
+ def doDescribeResourceSchedule(args, parsed_globals):
385
2673
  g_param = parse_global_arg(parsed_globals)
386
2674
 
387
2675
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -410,11 +2698,11 @@ def doModifyUserManagerPwd(args, parsed_globals):
410
2698
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
411
2699
  client._sdkVersion += ("_CLI_" + __version__)
412
2700
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
413
- model = models.ModifyUserManagerPwdRequest()
2701
+ model = models.DescribeResourceScheduleRequest()
414
2702
  model.from_json_string(json.dumps(args))
415
2703
  start_time = time.time()
416
2704
  while True:
417
- rsp = client.ModifyUserManagerPwd(model)
2705
+ rsp = client.DescribeResourceSchedule(model)
418
2706
  result = rsp.to_json_string()
419
2707
  try:
420
2708
  json_obj = json.loads(result)
@@ -433,7 +2721,7 @@ def doModifyUserManagerPwd(args, parsed_globals):
433
2721
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
434
2722
 
435
2723
 
436
- def doModifySLInstanceBasic(args, parsed_globals):
2724
+ def doResizeDataDisks(args, parsed_globals):
437
2725
  g_param = parse_global_arg(parsed_globals)
438
2726
 
439
2727
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -462,11 +2750,11 @@ def doModifySLInstanceBasic(args, parsed_globals):
462
2750
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
463
2751
  client._sdkVersion += ("_CLI_" + __version__)
464
2752
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
465
- model = models.ModifySLInstanceBasicRequest()
2753
+ model = models.ResizeDataDisksRequest()
466
2754
  model.from_json_string(json.dumps(args))
467
2755
  start_time = time.time()
468
2756
  while True:
469
- rsp = client.ModifySLInstanceBasic(model)
2757
+ rsp = client.ResizeDataDisks(model)
470
2758
  result = rsp.to_json_string()
471
2759
  try:
472
2760
  json_obj = json.loads(result)
@@ -485,7 +2773,7 @@ def doModifySLInstanceBasic(args, parsed_globals):
485
2773
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
486
2774
 
487
2775
 
488
- def doDescribeInstances(args, parsed_globals):
2776
+ def doModifyResourceScheduleConfig(args, parsed_globals):
489
2777
  g_param = parse_global_arg(parsed_globals)
490
2778
 
491
2779
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -514,11 +2802,11 @@ def doDescribeInstances(args, parsed_globals):
514
2802
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
515
2803
  client._sdkVersion += ("_CLI_" + __version__)
516
2804
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
517
- model = models.DescribeInstancesRequest()
2805
+ model = models.ModifyResourceScheduleConfigRequest()
518
2806
  model.from_json_string(json.dumps(args))
519
2807
  start_time = time.time()
520
2808
  while True:
521
- rsp = client.DescribeInstances(model)
2809
+ rsp = client.ModifyResourceScheduleConfig(model)
522
2810
  result = rsp.to_json_string()
523
2811
  try:
524
2812
  json_obj = json.loads(result)
@@ -537,7 +2825,7 @@ def doDescribeInstances(args, parsed_globals):
537
2825
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
538
2826
 
539
2827
 
540
- def doTerminateClusterNodes(args, parsed_globals):
2828
+ def doDescribeHiveQueries(args, parsed_globals):
541
2829
  g_param = parse_global_arg(parsed_globals)
542
2830
 
543
2831
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -566,11 +2854,11 @@ def doTerminateClusterNodes(args, parsed_globals):
566
2854
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
567
2855
  client._sdkVersion += ("_CLI_" + __version__)
568
2856
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
569
- model = models.TerminateClusterNodesRequest()
2857
+ model = models.DescribeHiveQueriesRequest()
570
2858
  model.from_json_string(json.dumps(args))
571
2859
  start_time = time.time()
572
2860
  while True:
573
- rsp = client.TerminateClusterNodes(model)
2861
+ rsp = client.DescribeHiveQueries(model)
574
2862
  result = rsp.to_json_string()
575
2863
  try:
576
2864
  json_obj = json.loads(result)
@@ -589,7 +2877,7 @@ def doTerminateClusterNodes(args, parsed_globals):
589
2877
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
590
2878
 
591
2879
 
592
- def doDescribeUsersForUserManager(args, parsed_globals):
2880
+ def doStartStopServiceOrMonitor(args, parsed_globals):
593
2881
  g_param = parse_global_arg(parsed_globals)
594
2882
 
595
2883
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -618,11 +2906,11 @@ def doDescribeUsersForUserManager(args, parsed_globals):
618
2906
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
619
2907
  client._sdkVersion += ("_CLI_" + __version__)
620
2908
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
621
- model = models.DescribeUsersForUserManagerRequest()
2909
+ model = models.StartStopServiceOrMonitorRequest()
622
2910
  model.from_json_string(json.dumps(args))
623
2911
  start_time = time.time()
624
2912
  while True:
625
- rsp = client.DescribeUsersForUserManager(model)
2913
+ rsp = client.StartStopServiceOrMonitor(model)
626
2914
  result = rsp.to_json_string()
627
2915
  try:
628
2916
  json_obj = json.loads(result)
@@ -641,7 +2929,7 @@ def doDescribeUsersForUserManager(args, parsed_globals):
641
2929
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
642
2930
 
643
2931
 
644
- def doTerminateSLInstance(args, parsed_globals):
2932
+ def doDescribeYarnScheduleHistory(args, parsed_globals):
645
2933
  g_param = parse_global_arg(parsed_globals)
646
2934
 
647
2935
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -670,11 +2958,11 @@ def doTerminateSLInstance(args, parsed_globals):
670
2958
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
671
2959
  client._sdkVersion += ("_CLI_" + __version__)
672
2960
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
673
- model = models.TerminateSLInstanceRequest()
2961
+ model = models.DescribeYarnScheduleHistoryRequest()
674
2962
  model.from_json_string(json.dumps(args))
675
2963
  start_time = time.time()
676
2964
  while True:
677
- rsp = client.TerminateSLInstance(model)
2965
+ rsp = client.DescribeYarnScheduleHistory(model)
678
2966
  result = rsp.to_json_string()
679
2967
  try:
680
2968
  json_obj = json.loads(result)
@@ -693,7 +2981,7 @@ def doTerminateSLInstance(args, parsed_globals):
693
2981
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
694
2982
 
695
2983
 
696
- def doAddUsersForUserManager(args, parsed_globals):
2984
+ def doModifyGlobalConfig(args, parsed_globals):
697
2985
  g_param = parse_global_arg(parsed_globals)
698
2986
 
699
2987
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -722,11 +3010,11 @@ def doAddUsersForUserManager(args, parsed_globals):
722
3010
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
723
3011
  client._sdkVersion += ("_CLI_" + __version__)
724
3012
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
725
- model = models.AddUsersForUserManagerRequest()
3013
+ model = models.ModifyGlobalConfigRequest()
726
3014
  model.from_json_string(json.dumps(args))
727
3015
  start_time = time.time()
728
3016
  while True:
729
- rsp = client.AddUsersForUserManager(model)
3017
+ rsp = client.ModifyGlobalConfig(model)
730
3018
  result = rsp.to_json_string()
731
3019
  try:
732
3020
  json_obj = json.loads(result)
@@ -745,7 +3033,7 @@ def doAddUsersForUserManager(args, parsed_globals):
745
3033
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
746
3034
 
747
3035
 
748
- def doCreateSLInstance(args, parsed_globals):
3036
+ def doTerminateInstance(args, parsed_globals):
749
3037
  g_param = parse_global_arg(parsed_globals)
750
3038
 
751
3039
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -774,11 +3062,11 @@ def doCreateSLInstance(args, parsed_globals):
774
3062
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
775
3063
  client._sdkVersion += ("_CLI_" + __version__)
776
3064
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
777
- model = models.CreateSLInstanceRequest()
3065
+ model = models.TerminateInstanceRequest()
778
3066
  model.from_json_string(json.dumps(args))
779
3067
  start_time = time.time()
780
3068
  while True:
781
- rsp = client.CreateSLInstance(model)
3069
+ rsp = client.TerminateInstance(model)
782
3070
  result = rsp.to_json_string()
783
3071
  try:
784
3072
  json_obj = json.loads(result)
@@ -797,7 +3085,7 @@ def doCreateSLInstance(args, parsed_globals):
797
3085
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
798
3086
 
799
3087
 
800
- def doDescribeSLInstanceList(args, parsed_globals):
3088
+ def doModifySLInstance(args, parsed_globals):
801
3089
  g_param = parse_global_arg(parsed_globals)
802
3090
 
803
3091
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -826,11 +3114,11 @@ def doDescribeSLInstanceList(args, parsed_globals):
826
3114
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
827
3115
  client._sdkVersion += ("_CLI_" + __version__)
828
3116
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
829
- model = models.DescribeSLInstanceListRequest()
3117
+ model = models.ModifySLInstanceRequest()
830
3118
  model.from_json_string(json.dumps(args))
831
3119
  start_time = time.time()
832
3120
  while True:
833
- rsp = client.DescribeSLInstanceList(model)
3121
+ rsp = client.ModifySLInstance(model)
834
3122
  result = rsp.to_json_string()
835
3123
  try:
836
3124
  json_obj = json.loads(result)
@@ -849,7 +3137,7 @@ def doDescribeSLInstanceList(args, parsed_globals):
849
3137
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
850
3138
 
851
3139
 
852
- def doDescribeEmrApplicationStatics(args, parsed_globals):
3140
+ def doDescribeNodeDataDisks(args, parsed_globals):
853
3141
  g_param = parse_global_arg(parsed_globals)
854
3142
 
855
3143
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -878,11 +3166,11 @@ def doDescribeEmrApplicationStatics(args, parsed_globals):
878
3166
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
879
3167
  client._sdkVersion += ("_CLI_" + __version__)
880
3168
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
881
- model = models.DescribeEmrApplicationStaticsRequest()
3169
+ model = models.DescribeNodeDataDisksRequest()
882
3170
  model.from_json_string(json.dumps(args))
883
3171
  start_time = time.time()
884
3172
  while True:
885
- rsp = client.DescribeEmrApplicationStatics(model)
3173
+ rsp = client.DescribeNodeDataDisks(model)
886
3174
  result = rsp.to_json_string()
887
3175
  try:
888
3176
  json_obj = json.loads(result)
@@ -901,7 +3189,7 @@ def doDescribeEmrApplicationStatics(args, parsed_globals):
901
3189
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
902
3190
 
903
3191
 
904
- def doModifyResourceScheduler(args, parsed_globals):
3192
+ def doDescribeNodeResourceConfigFast(args, parsed_globals):
905
3193
  g_param = parse_global_arg(parsed_globals)
906
3194
 
907
3195
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -930,11 +3218,11 @@ def doModifyResourceScheduler(args, parsed_globals):
930
3218
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
931
3219
  client._sdkVersion += ("_CLI_" + __version__)
932
3220
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
933
- model = models.ModifyResourceSchedulerRequest()
3221
+ model = models.DescribeNodeResourceConfigFastRequest()
934
3222
  model.from_json_string(json.dumps(args))
935
3223
  start_time = time.time()
936
3224
  while True:
937
- rsp = client.ModifyResourceScheduler(model)
3225
+ rsp = client.DescribeNodeResourceConfigFast(model)
938
3226
  result = rsp.to_json_string()
939
3227
  try:
940
3228
  json_obj = json.loads(result)
@@ -953,7 +3241,7 @@ def doModifyResourceScheduler(args, parsed_globals):
953
3241
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
954
3242
 
955
3243
 
956
- def doDescribeSLInstance(args, parsed_globals):
3244
+ def doDescribeAutoScaleStrategies(args, parsed_globals):
957
3245
  g_param = parse_global_arg(parsed_globals)
958
3246
 
959
3247
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -982,11 +3270,11 @@ def doDescribeSLInstance(args, parsed_globals):
982
3270
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
983
3271
  client._sdkVersion += ("_CLI_" + __version__)
984
3272
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
985
- model = models.DescribeSLInstanceRequest()
3273
+ model = models.DescribeAutoScaleStrategiesRequest()
986
3274
  model.from_json_string(json.dumps(args))
987
3275
  start_time = time.time()
988
3276
  while True:
989
- rsp = client.DescribeSLInstance(model)
3277
+ rsp = client.DescribeAutoScaleStrategies(model)
990
3278
  result = rsp.to_json_string()
991
3279
  try:
992
3280
  json_obj = json.loads(result)
@@ -1005,7 +3293,7 @@ def doDescribeSLInstance(args, parsed_globals):
1005
3293
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1006
3294
 
1007
3295
 
1008
- def doModifySLInstance(args, parsed_globals):
3296
+ def doDescribeGlobalConfig(args, parsed_globals):
1009
3297
  g_param = parse_global_arg(parsed_globals)
1010
3298
 
1011
3299
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1034,11 +3322,11 @@ def doModifySLInstance(args, parsed_globals):
1034
3322
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1035
3323
  client._sdkVersion += ("_CLI_" + __version__)
1036
3324
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1037
- model = models.ModifySLInstanceRequest()
3325
+ model = models.DescribeGlobalConfigRequest()
1038
3326
  model.from_json_string(json.dumps(args))
1039
3327
  start_time = time.time()
1040
3328
  while True:
1041
- rsp = client.ModifySLInstance(model)
3329
+ rsp = client.DescribeGlobalConfig(model)
1042
3330
  result = rsp.to_json_string()
1043
3331
  try:
1044
3332
  json_obj = json.loads(result)
@@ -1057,7 +3345,7 @@ def doModifySLInstance(args, parsed_globals):
1057
3345
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1058
3346
 
1059
3347
 
1060
- def doCreateInstance(args, parsed_globals):
3348
+ def doDescribeAutoScaleGroupGlobalConf(args, parsed_globals):
1061
3349
  g_param = parse_global_arg(parsed_globals)
1062
3350
 
1063
3351
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1086,11 +3374,11 @@ def doCreateInstance(args, parsed_globals):
1086
3374
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1087
3375
  client._sdkVersion += ("_CLI_" + __version__)
1088
3376
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1089
- model = models.CreateInstanceRequest()
3377
+ model = models.DescribeAutoScaleGroupGlobalConfRequest()
1090
3378
  model.from_json_string(json.dumps(args))
1091
3379
  start_time = time.time()
1092
3380
  while True:
1093
- rsp = client.CreateInstance(model)
3381
+ rsp = client.DescribeAutoScaleGroupGlobalConf(model)
1094
3382
  result = rsp.to_json_string()
1095
3383
  try:
1096
3384
  json_obj = json.loads(result)
@@ -1109,7 +3397,7 @@ def doCreateInstance(args, parsed_globals):
1109
3397
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1110
3398
 
1111
3399
 
1112
- def doInquiryPriceCreateInstance(args, parsed_globals):
3400
+ def doDescribeDAGInfo(args, parsed_globals):
1113
3401
  g_param = parse_global_arg(parsed_globals)
1114
3402
 
1115
3403
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1138,11 +3426,11 @@ def doInquiryPriceCreateInstance(args, parsed_globals):
1138
3426
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1139
3427
  client._sdkVersion += ("_CLI_" + __version__)
1140
3428
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1141
- model = models.InquiryPriceCreateInstanceRequest()
3429
+ model = models.DescribeDAGInfoRequest()
1142
3430
  model.from_json_string(json.dumps(args))
1143
3431
  start_time = time.time()
1144
3432
  while True:
1145
- rsp = client.InquiryPriceCreateInstance(model)
3433
+ rsp = client.DescribeDAGInfo(model)
1146
3434
  result = rsp.to_json_string()
1147
3435
  try:
1148
3436
  json_obj = json.loads(result)
@@ -1161,7 +3449,7 @@ def doInquiryPriceCreateInstance(args, parsed_globals):
1161
3449
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1162
3450
 
1163
3451
 
1164
- def doDescribeResourceSchedule(args, parsed_globals):
3452
+ def doDescribeClusterNodes(args, parsed_globals):
1165
3453
  g_param = parse_global_arg(parsed_globals)
1166
3454
 
1167
3455
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1190,11 +3478,11 @@ def doDescribeResourceSchedule(args, parsed_globals):
1190
3478
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1191
3479
  client._sdkVersion += ("_CLI_" + __version__)
1192
3480
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1193
- model = models.DescribeResourceScheduleRequest()
3481
+ model = models.DescribeClusterNodesRequest()
1194
3482
  model.from_json_string(json.dumps(args))
1195
3483
  start_time = time.time()
1196
3484
  while True:
1197
- rsp = client.DescribeResourceSchedule(model)
3485
+ rsp = client.DescribeClusterNodes(model)
1198
3486
  result = rsp.to_json_string()
1199
3487
  try:
1200
3488
  json_obj = json.loads(result)
@@ -1213,7 +3501,7 @@ def doDescribeResourceSchedule(args, parsed_globals):
1213
3501
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1214
3502
 
1215
3503
 
1216
- def doModifyResourceScheduleConfig(args, parsed_globals):
3504
+ def doDescribeTrinoQueryInfo(args, parsed_globals):
1217
3505
  g_param = parse_global_arg(parsed_globals)
1218
3506
 
1219
3507
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1242,11 +3530,11 @@ def doModifyResourceScheduleConfig(args, parsed_globals):
1242
3530
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1243
3531
  client._sdkVersion += ("_CLI_" + __version__)
1244
3532
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1245
- model = models.ModifyResourceScheduleConfigRequest()
3533
+ model = models.DescribeTrinoQueryInfoRequest()
1246
3534
  model.from_json_string(json.dumps(args))
1247
3535
  start_time = time.time()
1248
3536
  while True:
1249
- rsp = client.ModifyResourceScheduleConfig(model)
3537
+ rsp = client.DescribeTrinoQueryInfo(model)
1250
3538
  result = rsp.to_json_string()
1251
3539
  try:
1252
3540
  json_obj = json.loads(result)
@@ -1265,7 +3553,7 @@ def doModifyResourceScheduleConfig(args, parsed_globals):
1265
3553
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1266
3554
 
1267
3555
 
1268
- def doDescribeHiveQueries(args, parsed_globals):
3556
+ def doDescribeInstancesList(args, parsed_globals):
1269
3557
  g_param = parse_global_arg(parsed_globals)
1270
3558
 
1271
3559
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1294,11 +3582,11 @@ def doDescribeHiveQueries(args, parsed_globals):
1294
3582
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1295
3583
  client._sdkVersion += ("_CLI_" + __version__)
1296
3584
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1297
- model = models.DescribeHiveQueriesRequest()
3585
+ model = models.DescribeInstancesListRequest()
1298
3586
  model.from_json_string(json.dumps(args))
1299
3587
  start_time = time.time()
1300
3588
  while True:
1301
- rsp = client.DescribeHiveQueries(model)
3589
+ rsp = client.DescribeInstancesList(model)
1302
3590
  result = rsp.to_json_string()
1303
3591
  try:
1304
3592
  json_obj = json.loads(result)
@@ -1317,7 +3605,7 @@ def doDescribeHiveQueries(args, parsed_globals):
1317
3605
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1318
3606
 
1319
3607
 
1320
- def doStartStopServiceOrMonitor(args, parsed_globals):
3608
+ def doDescribeNodeSpec(args, parsed_globals):
1321
3609
  g_param = parse_global_arg(parsed_globals)
1322
3610
 
1323
3611
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1346,11 +3634,11 @@ def doStartStopServiceOrMonitor(args, parsed_globals):
1346
3634
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1347
3635
  client._sdkVersion += ("_CLI_" + __version__)
1348
3636
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1349
- model = models.StartStopServiceOrMonitorRequest()
3637
+ model = models.DescribeNodeSpecRequest()
1350
3638
  model.from_json_string(json.dumps(args))
1351
3639
  start_time = time.time()
1352
3640
  while True:
1353
- rsp = client.StartStopServiceOrMonitor(model)
3641
+ rsp = client.DescribeNodeSpec(model)
1354
3642
  result = rsp.to_json_string()
1355
3643
  try:
1356
3644
  json_obj = json.loads(result)
@@ -1369,7 +3657,7 @@ def doStartStopServiceOrMonitor(args, parsed_globals):
1369
3657
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1370
3658
 
1371
3659
 
1372
- def doTerminateTasks(args, parsed_globals):
3660
+ def doDescribeInsightList(args, parsed_globals):
1373
3661
  g_param = parse_global_arg(parsed_globals)
1374
3662
 
1375
3663
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1398,11 +3686,11 @@ def doTerminateTasks(args, parsed_globals):
1398
3686
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1399
3687
  client._sdkVersion += ("_CLI_" + __version__)
1400
3688
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1401
- model = models.TerminateTasksRequest()
3689
+ model = models.DescribeInsightListRequest()
1402
3690
  model.from_json_string(json.dumps(args))
1403
3691
  start_time = time.time()
1404
3692
  while True:
1405
- rsp = client.TerminateTasks(model)
3693
+ rsp = client.DescribeInsightList(model)
1406
3694
  result = rsp.to_json_string()
1407
3695
  try:
1408
3696
  json_obj = json.loads(result)
@@ -1421,7 +3709,7 @@ def doTerminateTasks(args, parsed_globals):
1421
3709
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1422
3710
 
1423
3711
 
1424
- def doTerminateInstance(args, parsed_globals):
3712
+ def doDeleteNodeResourceConfig(args, parsed_globals):
1425
3713
  g_param = parse_global_arg(parsed_globals)
1426
3714
 
1427
3715
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1450,11 +3738,11 @@ def doTerminateInstance(args, parsed_globals):
1450
3738
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1451
3739
  client._sdkVersion += ("_CLI_" + __version__)
1452
3740
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1453
- model = models.TerminateInstanceRequest()
3741
+ model = models.DeleteNodeResourceConfigRequest()
1454
3742
  model.from_json_string(json.dumps(args))
1455
3743
  start_time = time.time()
1456
3744
  while True:
1457
- rsp = client.TerminateInstance(model)
3745
+ rsp = client.DeleteNodeResourceConfig(model)
1458
3746
  result = rsp.to_json_string()
1459
3747
  try:
1460
3748
  json_obj = json.loads(result)
@@ -1473,7 +3761,7 @@ def doTerminateInstance(args, parsed_globals):
1473
3761
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1474
3762
 
1475
3763
 
1476
- def doDescribeClusterNodes(args, parsed_globals):
3764
+ def doModifyInstanceBasic(args, parsed_globals):
1477
3765
  g_param = parse_global_arg(parsed_globals)
1478
3766
 
1479
3767
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1502,11 +3790,11 @@ def doDescribeClusterNodes(args, parsed_globals):
1502
3790
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1503
3791
  client._sdkVersion += ("_CLI_" + __version__)
1504
3792
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1505
- model = models.DescribeClusterNodesRequest()
3793
+ model = models.ModifyInstanceBasicRequest()
1506
3794
  model.from_json_string(json.dumps(args))
1507
3795
  start_time = time.time()
1508
3796
  while True:
1509
- rsp = client.DescribeClusterNodes(model)
3797
+ rsp = client.ModifyInstanceBasic(model)
1510
3798
  result = rsp.to_json_string()
1511
3799
  try:
1512
3800
  json_obj = json.loads(result)
@@ -1525,7 +3813,7 @@ def doDescribeClusterNodes(args, parsed_globals):
1525
3813
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1526
3814
 
1527
3815
 
1528
- def doDescribeInstancesList(args, parsed_globals):
3816
+ def doModifyUsersOfGroupSTD(args, parsed_globals):
1529
3817
  g_param = parse_global_arg(parsed_globals)
1530
3818
 
1531
3819
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1554,11 +3842,115 @@ def doDescribeInstancesList(args, parsed_globals):
1554
3842
  client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
1555
3843
  client._sdkVersion += ("_CLI_" + __version__)
1556
3844
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1557
- model = models.DescribeInstancesListRequest()
3845
+ model = models.ModifyUsersOfGroupSTDRequest()
1558
3846
  model.from_json_string(json.dumps(args))
1559
3847
  start_time = time.time()
1560
3848
  while True:
1561
- rsp = client.DescribeInstancesList(model)
3849
+ rsp = client.ModifyUsersOfGroupSTD(model)
3850
+ result = rsp.to_json_string()
3851
+ try:
3852
+ json_obj = json.loads(result)
3853
+ except TypeError as e:
3854
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
3855
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
3856
+ break
3857
+ cur_time = time.time()
3858
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
3859
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
3860
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
3861
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
3862
+ else:
3863
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
3864
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
3865
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
3866
+
3867
+
3868
+ def doModifyInspectionSettings(args, parsed_globals):
3869
+ g_param = parse_global_arg(parsed_globals)
3870
+
3871
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
3872
+ cred = credential.CVMRoleCredential()
3873
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
3874
+ cred = credential.STSAssumeRoleCredential(
3875
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
3876
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
3877
+ )
3878
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
3879
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
3880
+ else:
3881
+ cred = credential.Credential(
3882
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
3883
+ )
3884
+ http_profile = HttpProfile(
3885
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
3886
+ reqMethod="POST",
3887
+ endpoint=g_param[OptionsDefine.Endpoint],
3888
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
3889
+ )
3890
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
3891
+ if g_param[OptionsDefine.Language]:
3892
+ profile.language = g_param[OptionsDefine.Language]
3893
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
3894
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
3895
+ client._sdkVersion += ("_CLI_" + __version__)
3896
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
3897
+ model = models.ModifyInspectionSettingsRequest()
3898
+ model.from_json_string(json.dumps(args))
3899
+ start_time = time.time()
3900
+ while True:
3901
+ rsp = client.ModifyInspectionSettings(model)
3902
+ result = rsp.to_json_string()
3903
+ try:
3904
+ json_obj = json.loads(result)
3905
+ except TypeError as e:
3906
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
3907
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
3908
+ break
3909
+ cur_time = time.time()
3910
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
3911
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
3912
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
3913
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
3914
+ else:
3915
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
3916
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
3917
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
3918
+
3919
+
3920
+ def doDescribeInspectionTaskResult(args, parsed_globals):
3921
+ g_param = parse_global_arg(parsed_globals)
3922
+
3923
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
3924
+ cred = credential.CVMRoleCredential()
3925
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
3926
+ cred = credential.STSAssumeRoleCredential(
3927
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
3928
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
3929
+ )
3930
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
3931
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
3932
+ else:
3933
+ cred = credential.Credential(
3934
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
3935
+ )
3936
+ http_profile = HttpProfile(
3937
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
3938
+ reqMethod="POST",
3939
+ endpoint=g_param[OptionsDefine.Endpoint],
3940
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
3941
+ )
3942
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
3943
+ if g_param[OptionsDefine.Language]:
3944
+ profile.language = g_param[OptionsDefine.Language]
3945
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
3946
+ client = mod.EmrClient(cred, g_param[OptionsDefine.Region], profile)
3947
+ client._sdkVersion += ("_CLI_" + __version__)
3948
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
3949
+ model = models.DescribeInspectionTaskResultRequest()
3950
+ model.from_json_string(json.dumps(args))
3951
+ start_time = time.time()
3952
+ while True:
3953
+ rsp = client.DescribeInspectionTaskResult(model)
1562
3954
  result = rsp.to_json_string()
1563
3955
  try:
1564
3956
  json_obj = json.loads(result)
@@ -1643,33 +4035,79 @@ ACTION_MAP = {
1643
4035
  "ModifyResourcesTags": doModifyResourcesTags,
1644
4036
  "InquiryPriceUpdateInstance": doInquiryPriceUpdateInstance,
1645
4037
  "CreateCluster": doCreateCluster,
4038
+ "DescribeServiceConfGroupInfos": doDescribeServiceConfGroupInfos,
1646
4039
  "InquiryPriceRenewInstance": doInquiryPriceRenewInstance,
4040
+ "DescribeGroupsSTD": doDescribeGroupsSTD,
4041
+ "DescribeYarnQueue": doDescribeYarnQueue,
4042
+ "ModifyYarnQueueV2": doModifyYarnQueueV2,
4043
+ "DeployYarnConf": doDeployYarnConf,
4044
+ "DescribeClusterFlowStatusDetail": doDescribeClusterFlowStatusDetail,
1647
4045
  "InquiryPriceScaleOutInstance": doInquiryPriceScaleOutInstance,
1648
4046
  "DescribeAutoScaleRecords": doDescribeAutoScaleRecords,
4047
+ "DescribeEmrOverviewMetrics": doDescribeEmrOverviewMetrics,
1649
4048
  "ScaleOutInstance": doScaleOutInstance,
1650
- "ModifyUserManagerPwd": doModifyUserManagerPwd,
4049
+ "AttachDisks": doAttachDisks,
4050
+ "SetNodeResourceConfigDefault": doSetNodeResourceConfigDefault,
4051
+ "DescribeStarRocksQueryInfo": doDescribeStarRocksQueryInfo,
1651
4052
  "ModifySLInstanceBasic": doModifySLInstanceBasic,
4053
+ "AddMetricScaleStrategy": doAddMetricScaleStrategy,
4054
+ "DescribeServiceNodeInfos": doDescribeServiceNodeInfos,
1652
4055
  "DescribeInstances": doDescribeInstances,
4056
+ "ModifyYarnDeploy": doModifyYarnDeploy,
4057
+ "TerminateTasks": doTerminateTasks,
4058
+ "DeleteGroupsSTD": doDeleteGroupsSTD,
1653
4059
  "TerminateClusterNodes": doTerminateClusterNodes,
4060
+ "ResetYarnConfig": doResetYarnConfig,
1654
4061
  "DescribeUsersForUserManager": doDescribeUsersForUserManager,
4062
+ "ModifyUserManagerPwd": doModifyUserManagerPwd,
4063
+ "ConvertPreToPostCluster": doConvertPreToPostCluster,
4064
+ "CreateGroupsSTD": doCreateGroupsSTD,
1655
4065
  "TerminateSLInstance": doTerminateSLInstance,
1656
4066
  "AddUsersForUserManager": doAddUsersForUserManager,
4067
+ "DescribeSparkApplications": doDescribeSparkApplications,
4068
+ "ModifyUserGroup": doModifyUserGroup,
1657
4069
  "CreateSLInstance": doCreateSLInstance,
1658
4070
  "DescribeSLInstanceList": doDescribeSLInstanceList,
4071
+ "AddNodeResourceConfig": doAddNodeResourceConfig,
4072
+ "ModifyAutoScaleStrategy": doModifyAutoScaleStrategy,
4073
+ "DescribeKyuubiQueryInfo": doDescribeKyuubiQueryInfo,
4074
+ "DeleteAutoScaleStrategy": doDeleteAutoScaleStrategy,
1659
4075
  "DescribeEmrApplicationStatics": doDescribeEmrApplicationStatics,
4076
+ "DescribeHDFSStorageInfo": doDescribeHDFSStorageInfo,
4077
+ "CreateInstance": doCreateInstance,
1660
4078
  "ModifyResourceScheduler": doModifyResourceScheduler,
4079
+ "DescribeHBaseTableOverview": doDescribeHBaseTableOverview,
4080
+ "DescribeResourceScheduleDiffDetail": doDescribeResourceScheduleDiffDetail,
1661
4081
  "DescribeSLInstance": doDescribeSLInstance,
1662
- "ModifySLInstance": doModifySLInstance,
1663
- "CreateInstance": doCreateInstance,
4082
+ "DescribeSparkQueries": doDescribeSparkQueries,
4083
+ "ModifyAutoRenewFlag": doModifyAutoRenewFlag,
4084
+ "ModifyResource": doModifyResource,
1664
4085
  "InquiryPriceCreateInstance": doInquiryPriceCreateInstance,
1665
4086
  "DescribeResourceSchedule": doDescribeResourceSchedule,
4087
+ "ResizeDataDisks": doResizeDataDisks,
1666
4088
  "ModifyResourceScheduleConfig": doModifyResourceScheduleConfig,
1667
4089
  "DescribeHiveQueries": doDescribeHiveQueries,
1668
4090
  "StartStopServiceOrMonitor": doStartStopServiceOrMonitor,
1669
- "TerminateTasks": doTerminateTasks,
4091
+ "DescribeYarnScheduleHistory": doDescribeYarnScheduleHistory,
4092
+ "ModifyGlobalConfig": doModifyGlobalConfig,
1670
4093
  "TerminateInstance": doTerminateInstance,
4094
+ "ModifySLInstance": doModifySLInstance,
4095
+ "DescribeNodeDataDisks": doDescribeNodeDataDisks,
4096
+ "DescribeNodeResourceConfigFast": doDescribeNodeResourceConfigFast,
4097
+ "DescribeAutoScaleStrategies": doDescribeAutoScaleStrategies,
4098
+ "DescribeGlobalConfig": doDescribeGlobalConfig,
4099
+ "DescribeAutoScaleGroupGlobalConf": doDescribeAutoScaleGroupGlobalConf,
4100
+ "DescribeDAGInfo": doDescribeDAGInfo,
1671
4101
  "DescribeClusterNodes": doDescribeClusterNodes,
4102
+ "DescribeTrinoQueryInfo": doDescribeTrinoQueryInfo,
1672
4103
  "DescribeInstancesList": doDescribeInstancesList,
4104
+ "DescribeNodeSpec": doDescribeNodeSpec,
4105
+ "DescribeInsightList": doDescribeInsightList,
4106
+ "DeleteNodeResourceConfig": doDeleteNodeResourceConfig,
4107
+ "ModifyInstanceBasic": doModifyInstanceBasic,
4108
+ "ModifyUsersOfGroupSTD": doModifyUsersOfGroupSTD,
4109
+ "ModifyInspectionSettings": doModifyInspectionSettings,
4110
+ "DescribeInspectionTaskResult": doDescribeInspectionTaskResult,
1673
4111
  "ScaleOutCluster": doScaleOutCluster,
1674
4112
 
1675
4113
  }