tccli 3.0.1363.1__py2.py3-none-any.whl → 3.0.1364.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 (31) hide show
  1. tccli/__init__.py +1 -1
  2. tccli/services/bi/v20220105/api.json +97 -5
  3. tccli/services/bi/v20220105/examples.json +5 -5
  4. tccli/services/cam/cam_client.py +61 -8
  5. tccli/services/cam/v20190116/api.json +96 -0
  6. tccli/services/cam/v20190116/examples.json +8 -0
  7. tccli/services/cdb/v20170320/api.json +35 -35
  8. tccli/services/cdb/v20170320/examples.json +3 -3
  9. tccli/services/cfs/cfs_client.py +817 -128
  10. tccli/services/cfs/v20190719/api.json +2241 -833
  11. tccli/services/cfs/v20190719/examples.json +104 -0
  12. tccli/services/clb/v20180317/api.json +29 -9
  13. tccli/services/cls/v20201016/api.json +59 -59
  14. tccli/services/cls/v20201016/examples.json +3 -3
  15. tccli/services/ctem/v20231128/api.json +331 -97
  16. tccli/services/ctem/v20231128/examples.json +8 -8
  17. tccli/services/kms/v20190118/api.json +2 -2
  18. tccli/services/live/v20180801/api.json +1 -1
  19. tccli/services/lowcode/lowcode_client.py +212 -0
  20. tccli/services/lowcode/v20210108/api.json +239 -0
  21. tccli/services/lowcode/v20210108/examples.json +32 -0
  22. tccli/services/ssl/v20191205/api.json +35 -25
  23. tccli/services/teo/v20220901/api.json +21 -1
  24. tccli/services/wedata/v20210820/api.json +191 -11
  25. tccli/services/wedata/v20210820/examples.json +10 -2
  26. tccli/services/wedata/wedata_client.py +53 -0
  27. {tccli-3.0.1363.1.dist-info → tccli-3.0.1364.1.dist-info}/METADATA +2 -2
  28. {tccli-3.0.1363.1.dist-info → tccli-3.0.1364.1.dist-info}/RECORD +31 -31
  29. {tccli-3.0.1363.1.dist-info → tccli-3.0.1364.1.dist-info}/WHEEL +0 -0
  30. {tccli-3.0.1363.1.dist-info → tccli-3.0.1364.1.dist-info}/entry_points.txt +0 -0
  31. {tccli-3.0.1363.1.dist-info → tccli-3.0.1364.1.dist-info}/license_files/LICENSE +0 -0
tccli/services/cfs/cfs_client.py CHANGED
@@ -121,7 +121,683 @@ def doUpdateCfsFileSystemPGroup(args, parsed_globals):
121
121
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
122
122
 
123
123
 
124
- def doSignUpCfsService(args, parsed_globals):
124
+ def doDescribeLifecycleDataTask(args, parsed_globals):
125
+ g_param = parse_global_arg(parsed_globals)
126
+
127
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
128
+ cred = credential.CVMRoleCredential()
129
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
130
+ cred = credential.STSAssumeRoleCredential(
131
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
132
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
133
+ )
134
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
135
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
136
+ else:
137
+ cred = credential.Credential(
138
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
139
+ )
140
+ http_profile = HttpProfile(
141
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
142
+ reqMethod="POST",
143
+ endpoint=g_param[OptionsDefine.Endpoint],
144
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
145
+ )
146
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
147
+ if g_param[OptionsDefine.Language]:
148
+ profile.language = g_param[OptionsDefine.Language]
149
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
150
+ client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
151
+ client._sdkVersion += ("_CLI_" + __version__)
152
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
153
+ model = models.DescribeLifecycleDataTaskRequest()
154
+ model.from_json_string(json.dumps(args))
155
+ start_time = time.time()
156
+ while True:
157
+ rsp = client.DescribeLifecycleDataTask(model)
158
+ result = rsp.to_json_string()
159
+ try:
160
+ json_obj = json.loads(result)
161
+ except TypeError as e:
162
+ json_obj = json.loads(result.decode('utf-8')) # python3.3
163
+ if not g_param[OptionsDefine.Waiter] or search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj) == g_param['OptionsDefine.WaiterInfo']['to']:
164
+ break
165
+ cur_time = time.time()
166
+ if cur_time - start_time >= g_param['OptionsDefine.WaiterInfo']['timeout']:
167
+ raise ClientError('Request timeout, wait `%s` to `%s` timeout, last request is %s' %
168
+ (g_param['OptionsDefine.WaiterInfo']['expr'], g_param['OptionsDefine.WaiterInfo']['to'],
169
+ search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj)))
170
+ else:
171
+ print('Inquiry result is %s.' % search(g_param['OptionsDefine.WaiterInfo']['expr'], json_obj))
172
+ time.sleep(g_param['OptionsDefine.WaiterInfo']['interval'])
173
+ FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
174
+
175
+
176
+ def doDeleteCfsSnapshot(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
203
+ client._sdkVersion += ("_CLI_" + __version__)
204
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
205
+ model = models.DeleteCfsSnapshotRequest()
206
+ model.from_json_string(json.dumps(args))
207
+ start_time = time.time()
208
+ while True:
209
+ rsp = client.DeleteCfsSnapshot(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
+
228
+ def doUpdateCfsSnapshotAttribute(args, parsed_globals):
229
+ g_param = parse_global_arg(parsed_globals)
230
+
231
+ if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
232
+ cred = credential.CVMRoleCredential()
233
+ elif g_param[OptionsDefine.RoleArn.replace('-', '_')] and g_param[OptionsDefine.RoleSessionName.replace('-', '_')]:
234
+ cred = credential.STSAssumeRoleCredential(
235
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.RoleArn.replace('-', '_')],
236
+ g_param[OptionsDefine.RoleSessionName.replace('-', '_')], endpoint=g_param["sts_cred_endpoint"]
237
+ )
238
+ elif os.getenv(OptionsDefine.ENV_TKE_REGION) and os.getenv(OptionsDefine.ENV_TKE_PROVIDER_ID) and os.getenv(OptionsDefine.ENV_TKE_WEB_IDENTITY_TOKEN_FILE) and os.getenv(OptionsDefine.ENV_TKE_ROLE_ARN):
239
+ cred = credential.DefaultTkeOIDCRoleArnProvider().get_credentials()
240
+ else:
241
+ cred = credential.Credential(
242
+ g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
243
+ )
244
+ http_profile = HttpProfile(
245
+ reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
246
+ reqMethod="POST",
247
+ endpoint=g_param[OptionsDefine.Endpoint],
248
+ proxy=g_param[OptionsDefine.HttpsProxy.replace('-', '_')]
249
+ )
250
+ profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
251
+ if g_param[OptionsDefine.Language]:
252
+ profile.language = g_param[OptionsDefine.Language]
253
+ mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
254
+ client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
255
+ client._sdkVersion += ("_CLI_" + __version__)
256
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
257
+ model = models.UpdateCfsSnapshotAttributeRequest()
258
+ model.from_json_string(json.dumps(args))
259
+ start_time = time.time()
260
+ while True:
261
+ rsp = client.UpdateCfsSnapshotAttribute(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 doSetUserQuota(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
307
+ client._sdkVersion += ("_CLI_" + __version__)
308
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
309
+ model = models.SetUserQuotaRequest()
310
+ model.from_json_string(json.dumps(args))
311
+ start_time = time.time()
312
+ while True:
313
+ rsp = client.SetUserQuota(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 doCreateCfsPGroup(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
359
+ client._sdkVersion += ("_CLI_" + __version__)
360
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
361
+ model = models.CreateCfsPGroupRequest()
362
+ model.from_json_string(json.dumps(args))
363
+ start_time = time.time()
364
+ while True:
365
+ rsp = client.CreateCfsPGroup(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 doBindAutoSnapshotPolicy(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
411
+ client._sdkVersion += ("_CLI_" + __version__)
412
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
413
+ model = models.BindAutoSnapshotPolicyRequest()
414
+ model.from_json_string(json.dumps(args))
415
+ start_time = time.time()
416
+ while True:
417
+ rsp = client.BindAutoSnapshotPolicy(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 doCreateDataFlow(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
463
+ client._sdkVersion += ("_CLI_" + __version__)
464
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
465
+ model = models.CreateDataFlowRequest()
466
+ model.from_json_string(json.dumps(args))
467
+ start_time = time.time()
468
+ while True:
469
+ rsp = client.CreateDataFlow(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 doDeleteCfsPGroup(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
515
+ client._sdkVersion += ("_CLI_" + __version__)
516
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
517
+ model = models.DeleteCfsPGroupRequest()
518
+ model.from_json_string(json.dumps(args))
519
+ start_time = time.time()
520
+ while True:
521
+ rsp = client.DeleteCfsPGroup(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 doDeleteLifecyclePolicy(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
567
+ client._sdkVersion += ("_CLI_" + __version__)
568
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
569
+ model = models.DeleteLifecyclePolicyRequest()
570
+ model.from_json_string(json.dumps(args))
571
+ start_time = time.time()
572
+ while True:
573
+ rsp = client.DeleteLifecyclePolicy(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 doCreateLifecyclePolicyDownloadTask(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
619
+ client._sdkVersion += ("_CLI_" + __version__)
620
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
621
+ model = models.CreateLifecyclePolicyDownloadTaskRequest()
622
+ model.from_json_string(json.dumps(args))
623
+ start_time = time.time()
624
+ while True:
625
+ rsp = client.CreateLifecyclePolicyDownloadTask(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 doDeleteCfsRule(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
671
+ client._sdkVersion += ("_CLI_" + __version__)
672
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
673
+ model = models.DeleteCfsRuleRequest()
674
+ model.from_json_string(json.dumps(args))
675
+ start_time = time.time()
676
+ while True:
677
+ rsp = client.DeleteCfsRule(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 doDescribeCfsServiceStatus(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
723
+ client._sdkVersion += ("_CLI_" + __version__)
724
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
725
+ model = models.DescribeCfsServiceStatusRequest()
726
+ model.from_json_string(json.dumps(args))
727
+ start_time = time.time()
728
+ while True:
729
+ rsp = client.DescribeCfsServiceStatus(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 doStopMigrationTask(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.CfsClient(cred, g_param[OptionsDefine.Region], profile)
775
+ client._sdkVersion += ("_CLI_" + __version__)
776
+ models = MODELS_MAP[g_param[OptionsDefine.Version]]
777
+ model = models.StopMigrationTaskRequest()
778
+ model.from_json_string(json.dumps(args))
779
+ start_time = time.time()
780
+ while True:
781
+ rsp = client.StopMigrationTask(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 doDescribeMigrationTasks(args, parsed_globals):
125
801
  g_param = parse_global_arg(parsed_globals)
126
802
 
127
803
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -150,11 +826,11 @@ def doSignUpCfsService(args, parsed_globals):
150
826
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
151
827
  client._sdkVersion += ("_CLI_" + __version__)
152
828
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
153
- model = models.SignUpCfsServiceRequest()
829
+ model = models.DescribeMigrationTasksRequest()
154
830
  model.from_json_string(json.dumps(args))
155
831
  start_time = time.time()
156
832
  while True:
157
- rsp = client.SignUpCfsService(model)
833
+ rsp = client.DescribeMigrationTasks(model)
158
834
  result = rsp.to_json_string()
159
835
  try:
160
836
  json_obj = json.loads(result)
@@ -173,7 +849,7 @@ def doSignUpCfsService(args, parsed_globals):
173
849
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
174
850
 
175
851
 
176
- def doDeleteCfsSnapshot(args, parsed_globals):
852
+ def doDescribeAvailableZoneInfo(args, parsed_globals):
177
853
  g_param = parse_global_arg(parsed_globals)
178
854
 
179
855
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -202,11 +878,11 @@ def doDeleteCfsSnapshot(args, parsed_globals):
202
878
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
203
879
  client._sdkVersion += ("_CLI_" + __version__)
204
880
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
205
- model = models.DeleteCfsSnapshotRequest()
881
+ model = models.DescribeAvailableZoneInfoRequest()
206
882
  model.from_json_string(json.dumps(args))
207
883
  start_time = time.time()
208
884
  while True:
209
- rsp = client.DeleteCfsSnapshot(model)
885
+ rsp = client.DescribeAvailableZoneInfo(model)
210
886
  result = rsp.to_json_string()
211
887
  try:
212
888
  json_obj = json.loads(result)
@@ -225,7 +901,7 @@ def doDeleteCfsSnapshot(args, parsed_globals):
225
901
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
226
902
 
227
903
 
228
- def doDescribeCfsPGroups(args, parsed_globals):
904
+ def doCreateLifecycleDataTask(args, parsed_globals):
229
905
  g_param = parse_global_arg(parsed_globals)
230
906
 
231
907
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -254,11 +930,11 @@ def doDescribeCfsPGroups(args, parsed_globals):
254
930
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
255
931
  client._sdkVersion += ("_CLI_" + __version__)
256
932
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
257
- model = models.DescribeCfsPGroupsRequest()
933
+ model = models.CreateLifecycleDataTaskRequest()
258
934
  model.from_json_string(json.dumps(args))
259
935
  start_time = time.time()
260
936
  while True:
261
- rsp = client.DescribeCfsPGroups(model)
937
+ rsp = client.CreateLifecycleDataTask(model)
262
938
  result = rsp.to_json_string()
263
939
  try:
264
940
  json_obj = json.loads(result)
@@ -277,7 +953,7 @@ def doDescribeCfsPGroups(args, parsed_globals):
277
953
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
278
954
 
279
955
 
280
- def doUpdateFileSystemBandwidthLimit(args, parsed_globals):
956
+ def doScaleUpFileSystem(args, parsed_globals):
281
957
  g_param = parse_global_arg(parsed_globals)
282
958
 
283
959
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -306,11 +982,11 @@ def doUpdateFileSystemBandwidthLimit(args, parsed_globals):
306
982
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
307
983
  client._sdkVersion += ("_CLI_" + __version__)
308
984
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
309
- model = models.UpdateFileSystemBandwidthLimitRequest()
985
+ model = models.ScaleUpFileSystemRequest()
310
986
  model.from_json_string(json.dumps(args))
311
987
  start_time = time.time()
312
988
  while True:
313
- rsp = client.UpdateFileSystemBandwidthLimit(model)
989
+ rsp = client.ScaleUpFileSystem(model)
314
990
  result = rsp.to_json_string()
315
991
  try:
316
992
  json_obj = json.loads(result)
@@ -329,7 +1005,7 @@ def doUpdateFileSystemBandwidthLimit(args, parsed_globals):
329
1005
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
330
1006
 
331
1007
 
332
- def doSetUserQuota(args, parsed_globals):
1008
+ def doSignUpCfsService(args, parsed_globals):
333
1009
  g_param = parse_global_arg(parsed_globals)
334
1010
 
335
1011
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -358,11 +1034,11 @@ def doSetUserQuota(args, parsed_globals):
358
1034
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
359
1035
  client._sdkVersion += ("_CLI_" + __version__)
360
1036
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
361
- model = models.SetUserQuotaRequest()
1037
+ model = models.SignUpCfsServiceRequest()
362
1038
  model.from_json_string(json.dumps(args))
363
1039
  start_time = time.time()
364
1040
  while True:
365
- rsp = client.SetUserQuota(model)
1041
+ rsp = client.SignUpCfsService(model)
366
1042
  result = rsp.to_json_string()
367
1043
  try:
368
1044
  json_obj = json.loads(result)
@@ -381,7 +1057,7 @@ def doSetUserQuota(args, parsed_globals):
381
1057
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
382
1058
 
383
1059
 
384
- def doDescribeAutoSnapshotPolicies(args, parsed_globals):
1060
+ def doCreateAutoSnapshotPolicy(args, parsed_globals):
385
1061
  g_param = parse_global_arg(parsed_globals)
386
1062
 
387
1063
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -410,11 +1086,11 @@ def doDescribeAutoSnapshotPolicies(args, parsed_globals):
410
1086
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
411
1087
  client._sdkVersion += ("_CLI_" + __version__)
412
1088
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
413
- model = models.DescribeAutoSnapshotPoliciesRequest()
1089
+ model = models.CreateAutoSnapshotPolicyRequest()
414
1090
  model.from_json_string(json.dumps(args))
415
1091
  start_time = time.time()
416
1092
  while True:
417
- rsp = client.DescribeAutoSnapshotPolicies(model)
1093
+ rsp = client.CreateAutoSnapshotPolicy(model)
418
1094
  result = rsp.to_json_string()
419
1095
  try:
420
1096
  json_obj = json.loads(result)
@@ -433,7 +1109,7 @@ def doDescribeAutoSnapshotPolicies(args, parsed_globals):
433
1109
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
434
1110
 
435
1111
 
436
- def doBindAutoSnapshotPolicy(args, parsed_globals):
1112
+ def doDeleteMigrationTask(args, parsed_globals):
437
1113
  g_param = parse_global_arg(parsed_globals)
438
1114
 
439
1115
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -462,11 +1138,11 @@ def doBindAutoSnapshotPolicy(args, parsed_globals):
462
1138
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
463
1139
  client._sdkVersion += ("_CLI_" + __version__)
464
1140
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
465
- model = models.BindAutoSnapshotPolicyRequest()
1141
+ model = models.DeleteMigrationTaskRequest()
466
1142
  model.from_json_string(json.dumps(args))
467
1143
  start_time = time.time()
468
1144
  while True:
469
- rsp = client.BindAutoSnapshotPolicy(model)
1145
+ rsp = client.DeleteMigrationTask(model)
470
1146
  result = rsp.to_json_string()
471
1147
  try:
472
1148
  json_obj = json.loads(result)
@@ -485,7 +1161,7 @@ def doBindAutoSnapshotPolicy(args, parsed_globals):
485
1161
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
486
1162
 
487
1163
 
488
- def doDeleteCfsPGroup(args, parsed_globals):
1164
+ def doUpdateFileSystemBandwidthLimit(args, parsed_globals):
489
1165
  g_param = parse_global_arg(parsed_globals)
490
1166
 
491
1167
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -514,11 +1190,11 @@ def doDeleteCfsPGroup(args, parsed_globals):
514
1190
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
515
1191
  client._sdkVersion += ("_CLI_" + __version__)
516
1192
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
517
- model = models.DeleteCfsPGroupRequest()
1193
+ model = models.UpdateFileSystemBandwidthLimitRequest()
518
1194
  model.from_json_string(json.dumps(args))
519
1195
  start_time = time.time()
520
1196
  while True:
521
- rsp = client.DeleteCfsPGroup(model)
1197
+ rsp = client.UpdateFileSystemBandwidthLimit(model)
522
1198
  result = rsp.to_json_string()
523
1199
  try:
524
1200
  json_obj = json.loads(result)
@@ -537,7 +1213,7 @@ def doDeleteCfsPGroup(args, parsed_globals):
537
1213
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
538
1214
 
539
1215
 
540
- def doDeleteCfsRule(args, parsed_globals):
1216
+ def doUpdateCfsFileSystemSizeLimit(args, parsed_globals):
541
1217
  g_param = parse_global_arg(parsed_globals)
542
1218
 
543
1219
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -566,11 +1242,11 @@ def doDeleteCfsRule(args, parsed_globals):
566
1242
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
567
1243
  client._sdkVersion += ("_CLI_" + __version__)
568
1244
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
569
- model = models.DeleteCfsRuleRequest()
1245
+ model = models.UpdateCfsFileSystemSizeLimitRequest()
570
1246
  model.from_json_string(json.dumps(args))
571
1247
  start_time = time.time()
572
1248
  while True:
573
- rsp = client.DeleteCfsRule(model)
1249
+ rsp = client.UpdateCfsFileSystemSizeLimit(model)
574
1250
  result = rsp.to_json_string()
575
1251
  try:
576
1252
  json_obj = json.loads(result)
@@ -589,7 +1265,7 @@ def doDeleteCfsRule(args, parsed_globals):
589
1265
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
590
1266
 
591
1267
 
592
- def doDescribeCfsServiceStatus(args, parsed_globals):
1268
+ def doDeleteDataFlow(args, parsed_globals):
593
1269
  g_param = parse_global_arg(parsed_globals)
594
1270
 
595
1271
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -618,11 +1294,11 @@ def doDescribeCfsServiceStatus(args, parsed_globals):
618
1294
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
619
1295
  client._sdkVersion += ("_CLI_" + __version__)
620
1296
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
621
- model = models.DescribeCfsServiceStatusRequest()
1297
+ model = models.DeleteDataFlowRequest()
622
1298
  model.from_json_string(json.dumps(args))
623
1299
  start_time = time.time()
624
1300
  while True:
625
- rsp = client.DescribeCfsServiceStatus(model)
1301
+ rsp = client.DeleteDataFlow(model)
626
1302
  result = rsp.to_json_string()
627
1303
  try:
628
1304
  json_obj = json.loads(result)
@@ -641,7 +1317,7 @@ def doDescribeCfsServiceStatus(args, parsed_globals):
641
1317
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
642
1318
 
643
1319
 
644
- def doStopMigrationTask(args, parsed_globals):
1320
+ def doCreateLifecyclePolicy(args, parsed_globals):
645
1321
  g_param = parse_global_arg(parsed_globals)
646
1322
 
647
1323
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -670,11 +1346,11 @@ def doStopMigrationTask(args, parsed_globals):
670
1346
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
671
1347
  client._sdkVersion += ("_CLI_" + __version__)
672
1348
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
673
- model = models.StopMigrationTaskRequest()
1349
+ model = models.CreateLifecyclePolicyRequest()
674
1350
  model.from_json_string(json.dumps(args))
675
1351
  start_time = time.time()
676
1352
  while True:
677
- rsp = client.StopMigrationTask(model)
1353
+ rsp = client.CreateLifecyclePolicy(model)
678
1354
  result = rsp.to_json_string()
679
1355
  try:
680
1356
  json_obj = json.loads(result)
@@ -693,7 +1369,7 @@ def doStopMigrationTask(args, parsed_globals):
693
1369
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
694
1370
 
695
1371
 
696
- def doDescribeMigrationTasks(args, parsed_globals):
1372
+ def doDeleteCfsFileSystem(args, parsed_globals):
697
1373
  g_param = parse_global_arg(parsed_globals)
698
1374
 
699
1375
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -722,11 +1398,11 @@ def doDescribeMigrationTasks(args, parsed_globals):
722
1398
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
723
1399
  client._sdkVersion += ("_CLI_" + __version__)
724
1400
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
725
- model = models.DescribeMigrationTasksRequest()
1401
+ model = models.DeleteCfsFileSystemRequest()
726
1402
  model.from_json_string(json.dumps(args))
727
1403
  start_time = time.time()
728
1404
  while True:
729
- rsp = client.DescribeMigrationTasks(model)
1405
+ rsp = client.DeleteCfsFileSystem(model)
730
1406
  result = rsp.to_json_string()
731
1407
  try:
732
1408
  json_obj = json.loads(result)
@@ -745,7 +1421,7 @@ def doDescribeMigrationTasks(args, parsed_globals):
745
1421
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
746
1422
 
747
1423
 
748
- def doDescribeAvailableZoneInfo(args, parsed_globals):
1424
+ def doCreateCfsFileSystem(args, parsed_globals):
749
1425
  g_param = parse_global_arg(parsed_globals)
750
1426
 
751
1427
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -774,11 +1450,11 @@ def doDescribeAvailableZoneInfo(args, parsed_globals):
774
1450
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
775
1451
  client._sdkVersion += ("_CLI_" + __version__)
776
1452
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
777
- model = models.DescribeAvailableZoneInfoRequest()
1453
+ model = models.CreateCfsFileSystemRequest()
778
1454
  model.from_json_string(json.dumps(args))
779
1455
  start_time = time.time()
780
1456
  while True:
781
- rsp = client.DescribeAvailableZoneInfo(model)
1457
+ rsp = client.CreateCfsFileSystem(model)
782
1458
  result = rsp.to_json_string()
783
1459
  try:
784
1460
  json_obj = json.loads(result)
@@ -797,7 +1473,7 @@ def doDescribeAvailableZoneInfo(args, parsed_globals):
797
1473
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
798
1474
 
799
1475
 
800
- def doUpdateCfsFileSystemName(args, parsed_globals):
1476
+ def doDescribeCfsPGroups(args, parsed_globals):
801
1477
  g_param = parse_global_arg(parsed_globals)
802
1478
 
803
1479
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -826,11 +1502,11 @@ def doUpdateCfsFileSystemName(args, parsed_globals):
826
1502
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
827
1503
  client._sdkVersion += ("_CLI_" + __version__)
828
1504
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
829
- model = models.UpdateCfsFileSystemNameRequest()
1505
+ model = models.DescribeCfsPGroupsRequest()
830
1506
  model.from_json_string(json.dumps(args))
831
1507
  start_time = time.time()
832
1508
  while True:
833
- rsp = client.UpdateCfsFileSystemName(model)
1509
+ rsp = client.DescribeCfsPGroups(model)
834
1510
  result = rsp.to_json_string()
835
1511
  try:
836
1512
  json_obj = json.loads(result)
@@ -849,7 +1525,7 @@ def doUpdateCfsFileSystemName(args, parsed_globals):
849
1525
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
850
1526
 
851
1527
 
852
- def doDeleteMigrationTask(args, parsed_globals):
1528
+ def doDescribeCfsSnapshotOverview(args, parsed_globals):
853
1529
  g_param = parse_global_arg(parsed_globals)
854
1530
 
855
1531
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -878,11 +1554,11 @@ def doDeleteMigrationTask(args, parsed_globals):
878
1554
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
879
1555
  client._sdkVersion += ("_CLI_" + __version__)
880
1556
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
881
- model = models.DeleteMigrationTaskRequest()
1557
+ model = models.DescribeCfsSnapshotOverviewRequest()
882
1558
  model.from_json_string(json.dumps(args))
883
1559
  start_time = time.time()
884
1560
  while True:
885
- rsp = client.DeleteMigrationTask(model)
1561
+ rsp = client.DescribeCfsSnapshotOverview(model)
886
1562
  result = rsp.to_json_string()
887
1563
  try:
888
1564
  json_obj = json.loads(result)
@@ -901,7 +1577,7 @@ def doDeleteMigrationTask(args, parsed_globals):
901
1577
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
902
1578
 
903
1579
 
904
- def doScaleUpFileSystem(args, parsed_globals):
1580
+ def doDescribeLifecyclePolicies(args, parsed_globals):
905
1581
  g_param = parse_global_arg(parsed_globals)
906
1582
 
907
1583
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -930,11 +1606,11 @@ def doScaleUpFileSystem(args, parsed_globals):
930
1606
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
931
1607
  client._sdkVersion += ("_CLI_" + __version__)
932
1608
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
933
- model = models.ScaleUpFileSystemRequest()
1609
+ model = models.DescribeLifecyclePoliciesRequest()
934
1610
  model.from_json_string(json.dumps(args))
935
1611
  start_time = time.time()
936
1612
  while True:
937
- rsp = client.ScaleUpFileSystem(model)
1613
+ rsp = client.DescribeLifecyclePolicies(model)
938
1614
  result = rsp.to_json_string()
939
1615
  try:
940
1616
  json_obj = json.loads(result)
@@ -953,7 +1629,7 @@ def doScaleUpFileSystem(args, parsed_globals):
953
1629
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
954
1630
 
955
1631
 
956
- def doUpdateCfsFileSystemSizeLimit(args, parsed_globals):
1632
+ def doDescribeUserQuota(args, parsed_globals):
957
1633
  g_param = parse_global_arg(parsed_globals)
958
1634
 
959
1635
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -982,11 +1658,11 @@ def doUpdateCfsFileSystemSizeLimit(args, parsed_globals):
982
1658
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
983
1659
  client._sdkVersion += ("_CLI_" + __version__)
984
1660
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
985
- model = models.UpdateCfsFileSystemSizeLimitRequest()
1661
+ model = models.DescribeUserQuotaRequest()
986
1662
  model.from_json_string(json.dumps(args))
987
1663
  start_time = time.time()
988
1664
  while True:
989
- rsp = client.UpdateCfsFileSystemSizeLimit(model)
1665
+ rsp = client.DescribeUserQuota(model)
990
1666
  result = rsp.to_json_string()
991
1667
  try:
992
1668
  json_obj = json.loads(result)
@@ -1005,7 +1681,7 @@ def doUpdateCfsFileSystemSizeLimit(args, parsed_globals):
1005
1681
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1006
1682
 
1007
1683
 
1008
- def doDeleteUserQuota(args, parsed_globals):
1684
+ def doApplyPathLifecyclePolicy(args, parsed_globals):
1009
1685
  g_param = parse_global_arg(parsed_globals)
1010
1686
 
1011
1687
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1034,11 +1710,11 @@ def doDeleteUserQuota(args, parsed_globals):
1034
1710
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1035
1711
  client._sdkVersion += ("_CLI_" + __version__)
1036
1712
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1037
- model = models.DeleteUserQuotaRequest()
1713
+ model = models.ApplyPathLifecyclePolicyRequest()
1038
1714
  model.from_json_string(json.dumps(args))
1039
1715
  start_time = time.time()
1040
1716
  while True:
1041
- rsp = client.DeleteUserQuota(model)
1717
+ rsp = client.ApplyPathLifecyclePolicy(model)
1042
1718
  result = rsp.to_json_string()
1043
1719
  try:
1044
1720
  json_obj = json.loads(result)
@@ -1057,7 +1733,7 @@ def doDeleteUserQuota(args, parsed_globals):
1057
1733
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1058
1734
 
1059
1735
 
1060
- def doDeleteCfsFileSystem(args, parsed_globals):
1736
+ def doModifyFileSystemAutoScaleUpRule(args, parsed_globals):
1061
1737
  g_param = parse_global_arg(parsed_globals)
1062
1738
 
1063
1739
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1086,11 +1762,11 @@ def doDeleteCfsFileSystem(args, parsed_globals):
1086
1762
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1087
1763
  client._sdkVersion += ("_CLI_" + __version__)
1088
1764
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1089
- model = models.DeleteCfsFileSystemRequest()
1765
+ model = models.ModifyFileSystemAutoScaleUpRuleRequest()
1090
1766
  model.from_json_string(json.dumps(args))
1091
1767
  start_time = time.time()
1092
1768
  while True:
1093
- rsp = client.DeleteCfsFileSystem(model)
1769
+ rsp = client.ModifyFileSystemAutoScaleUpRule(model)
1094
1770
  result = rsp.to_json_string()
1095
1771
  try:
1096
1772
  json_obj = json.loads(result)
@@ -1109,7 +1785,7 @@ def doDeleteCfsFileSystem(args, parsed_globals):
1109
1785
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1110
1786
 
1111
1787
 
1112
- def doCreateCfsFileSystem(args, parsed_globals):
1788
+ def doModifyDataFlow(args, parsed_globals):
1113
1789
  g_param = parse_global_arg(parsed_globals)
1114
1790
 
1115
1791
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1138,11 +1814,11 @@ def doCreateCfsFileSystem(args, parsed_globals):
1138
1814
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1139
1815
  client._sdkVersion += ("_CLI_" + __version__)
1140
1816
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1141
- model = models.CreateCfsFileSystemRequest()
1817
+ model = models.ModifyDataFlowRequest()
1142
1818
  model.from_json_string(json.dumps(args))
1143
1819
  start_time = time.time()
1144
1820
  while True:
1145
- rsp = client.CreateCfsFileSystem(model)
1821
+ rsp = client.ModifyDataFlow(model)
1146
1822
  result = rsp.to_json_string()
1147
1823
  try:
1148
1824
  json_obj = json.loads(result)
@@ -1161,7 +1837,7 @@ def doCreateCfsFileSystem(args, parsed_globals):
1161
1837
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1162
1838
 
1163
1839
 
1164
- def doUpdateCfsSnapshotAttribute(args, parsed_globals):
1840
+ def doCreateAccessCert(args, parsed_globals):
1165
1841
  g_param = parse_global_arg(parsed_globals)
1166
1842
 
1167
1843
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1190,11 +1866,11 @@ def doUpdateCfsSnapshotAttribute(args, parsed_globals):
1190
1866
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1191
1867
  client._sdkVersion += ("_CLI_" + __version__)
1192
1868
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1193
- model = models.UpdateCfsSnapshotAttributeRequest()
1869
+ model = models.CreateAccessCertRequest()
1194
1870
  model.from_json_string(json.dumps(args))
1195
1871
  start_time = time.time()
1196
1872
  while True:
1197
- rsp = client.UpdateCfsSnapshotAttribute(model)
1873
+ rsp = client.CreateAccessCert(model)
1198
1874
  result = rsp.to_json_string()
1199
1875
  try:
1200
1876
  json_obj = json.loads(result)
@@ -1213,7 +1889,7 @@ def doUpdateCfsSnapshotAttribute(args, parsed_globals):
1213
1889
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1214
1890
 
1215
1891
 
1216
- def doDescribeCfsSnapshotOverview(args, parsed_globals):
1892
+ def doDescribeCfsFileSystems(args, parsed_globals):
1217
1893
  g_param = parse_global_arg(parsed_globals)
1218
1894
 
1219
1895
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1242,11 +1918,11 @@ def doDescribeCfsSnapshotOverview(args, parsed_globals):
1242
1918
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1243
1919
  client._sdkVersion += ("_CLI_" + __version__)
1244
1920
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1245
- model = models.DescribeCfsSnapshotOverviewRequest()
1921
+ model = models.DescribeCfsFileSystemsRequest()
1246
1922
  model.from_json_string(json.dumps(args))
1247
1923
  start_time = time.time()
1248
1924
  while True:
1249
- rsp = client.DescribeCfsSnapshotOverview(model)
1925
+ rsp = client.DescribeCfsFileSystems(model)
1250
1926
  result = rsp.to_json_string()
1251
1927
  try:
1252
1928
  json_obj = json.loads(result)
@@ -1265,7 +1941,7 @@ def doDescribeCfsSnapshotOverview(args, parsed_globals):
1265
1941
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1266
1942
 
1267
1943
 
1268
- def doDescribeUserQuota(args, parsed_globals):
1944
+ def doDescribeCfsSnapshots(args, parsed_globals):
1269
1945
  g_param = parse_global_arg(parsed_globals)
1270
1946
 
1271
1947
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1294,11 +1970,11 @@ def doDescribeUserQuota(args, parsed_globals):
1294
1970
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1295
1971
  client._sdkVersion += ("_CLI_" + __version__)
1296
1972
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1297
- model = models.DescribeUserQuotaRequest()
1973
+ model = models.DescribeCfsSnapshotsRequest()
1298
1974
  model.from_json_string(json.dumps(args))
1299
1975
  start_time = time.time()
1300
1976
  while True:
1301
- rsp = client.DescribeUserQuota(model)
1977
+ rsp = client.DescribeCfsSnapshots(model)
1302
1978
  result = rsp.to_json_string()
1303
1979
  try:
1304
1980
  json_obj = json.loads(result)
@@ -1317,7 +1993,7 @@ def doDescribeUserQuota(args, parsed_globals):
1317
1993
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1318
1994
 
1319
1995
 
1320
- def doModifyFileSystemAutoScaleUpRule(args, parsed_globals):
1996
+ def doDescribeMountTargets(args, parsed_globals):
1321
1997
  g_param = parse_global_arg(parsed_globals)
1322
1998
 
1323
1999
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1346,11 +2022,11 @@ def doModifyFileSystemAutoScaleUpRule(args, parsed_globals):
1346
2022
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1347
2023
  client._sdkVersion += ("_CLI_" + __version__)
1348
2024
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1349
- model = models.ModifyFileSystemAutoScaleUpRuleRequest()
2025
+ model = models.DescribeMountTargetsRequest()
1350
2026
  model.from_json_string(json.dumps(args))
1351
2027
  start_time = time.time()
1352
2028
  while True:
1353
- rsp = client.ModifyFileSystemAutoScaleUpRule(model)
2029
+ rsp = client.DescribeMountTargets(model)
1354
2030
  result = rsp.to_json_string()
1355
2031
  try:
1356
2032
  json_obj = json.loads(result)
@@ -1369,7 +2045,7 @@ def doModifyFileSystemAutoScaleUpRule(args, parsed_globals):
1369
2045
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1370
2046
 
1371
2047
 
1372
- def doUpdateAutoSnapshotPolicy(args, parsed_globals):
2048
+ def doModifyLifecyclePolicy(args, parsed_globals):
1373
2049
  g_param = parse_global_arg(parsed_globals)
1374
2050
 
1375
2051
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1398,11 +2074,11 @@ def doUpdateAutoSnapshotPolicy(args, parsed_globals):
1398
2074
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1399
2075
  client._sdkVersion += ("_CLI_" + __version__)
1400
2076
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1401
- model = models.UpdateAutoSnapshotPolicyRequest()
2077
+ model = models.ModifyLifecyclePolicyRequest()
1402
2078
  model.from_json_string(json.dumps(args))
1403
2079
  start_time = time.time()
1404
2080
  while True:
1405
- rsp = client.UpdateAutoSnapshotPolicy(model)
2081
+ rsp = client.ModifyLifecyclePolicy(model)
1406
2082
  result = rsp.to_json_string()
1407
2083
  try:
1408
2084
  json_obj = json.loads(result)
@@ -1421,7 +2097,7 @@ def doUpdateAutoSnapshotPolicy(args, parsed_globals):
1421
2097
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1422
2098
 
1423
2099
 
1424
- def doCreateAccessCert(args, parsed_globals):
2100
+ def doDescribeCfsFileSystemClients(args, parsed_globals):
1425
2101
  g_param = parse_global_arg(parsed_globals)
1426
2102
 
1427
2103
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1450,11 +2126,11 @@ def doCreateAccessCert(args, parsed_globals):
1450
2126
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1451
2127
  client._sdkVersion += ("_CLI_" + __version__)
1452
2128
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1453
- model = models.CreateAccessCertRequest()
2129
+ model = models.DescribeCfsFileSystemClientsRequest()
1454
2130
  model.from_json_string(json.dumps(args))
1455
2131
  start_time = time.time()
1456
2132
  while True:
1457
- rsp = client.CreateAccessCert(model)
2133
+ rsp = client.DescribeCfsFileSystemClients(model)
1458
2134
  result = rsp.to_json_string()
1459
2135
  try:
1460
2136
  json_obj = json.loads(result)
@@ -1473,7 +2149,7 @@ def doCreateAccessCert(args, parsed_globals):
1473
2149
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1474
2150
 
1475
2151
 
1476
- def doDescribeCfsFileSystems(args, parsed_globals):
2152
+ def doDescribeBucketList(args, parsed_globals):
1477
2153
  g_param = parse_global_arg(parsed_globals)
1478
2154
 
1479
2155
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1502,11 +2178,11 @@ def doDescribeCfsFileSystems(args, parsed_globals):
1502
2178
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1503
2179
  client._sdkVersion += ("_CLI_" + __version__)
1504
2180
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1505
- model = models.DescribeCfsFileSystemsRequest()
2181
+ model = models.DescribeBucketListRequest()
1506
2182
  model.from_json_string(json.dumps(args))
1507
2183
  start_time = time.time()
1508
2184
  while True:
1509
- rsp = client.DescribeCfsFileSystems(model)
2185
+ rsp = client.DescribeBucketList(model)
1510
2186
  result = rsp.to_json_string()
1511
2187
  try:
1512
2188
  json_obj = json.loads(result)
@@ -1525,7 +2201,7 @@ def doDescribeCfsFileSystems(args, parsed_globals):
1525
2201
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1526
2202
 
1527
2203
 
1528
- def doDescribeCfsSnapshots(args, parsed_globals):
2204
+ def doCreateMigrationTask(args, parsed_globals):
1529
2205
  g_param = parse_global_arg(parsed_globals)
1530
2206
 
1531
2207
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1554,11 +2230,11 @@ def doDescribeCfsSnapshots(args, parsed_globals):
1554
2230
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1555
2231
  client._sdkVersion += ("_CLI_" + __version__)
1556
2232
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1557
- model = models.DescribeCfsSnapshotsRequest()
2233
+ model = models.CreateMigrationTaskRequest()
1558
2234
  model.from_json_string(json.dumps(args))
1559
2235
  start_time = time.time()
1560
2236
  while True:
1561
- rsp = client.DescribeCfsSnapshots(model)
2237
+ rsp = client.CreateMigrationTask(model)
1562
2238
  result = rsp.to_json_string()
1563
2239
  try:
1564
2240
  json_obj = json.loads(result)
@@ -1577,7 +2253,7 @@ def doDescribeCfsSnapshots(args, parsed_globals):
1577
2253
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1578
2254
 
1579
2255
 
1580
- def doDescribeMountTargets(args, parsed_globals):
2256
+ def doDeleteMountTarget(args, parsed_globals):
1581
2257
  g_param = parse_global_arg(parsed_globals)
1582
2258
 
1583
2259
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1606,11 +2282,11 @@ def doDescribeMountTargets(args, parsed_globals):
1606
2282
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1607
2283
  client._sdkVersion += ("_CLI_" + __version__)
1608
2284
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1609
- model = models.DescribeMountTargetsRequest()
2285
+ model = models.DeleteMountTargetRequest()
1610
2286
  model.from_json_string(json.dumps(args))
1611
2287
  start_time = time.time()
1612
2288
  while True:
1613
- rsp = client.DescribeMountTargets(model)
2289
+ rsp = client.DeleteMountTarget(model)
1614
2290
  result = rsp.to_json_string()
1615
2291
  try:
1616
2292
  json_obj = json.loads(result)
@@ -1629,7 +2305,7 @@ def doDescribeMountTargets(args, parsed_globals):
1629
2305
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1630
2306
 
1631
2307
 
1632
- def doDescribeCfsFileSystemClients(args, parsed_globals):
2308
+ def doDeleteUserQuota(args, parsed_globals):
1633
2309
  g_param = parse_global_arg(parsed_globals)
1634
2310
 
1635
2311
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1658,11 +2334,11 @@ def doDescribeCfsFileSystemClients(args, parsed_globals):
1658
2334
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1659
2335
  client._sdkVersion += ("_CLI_" + __version__)
1660
2336
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1661
- model = models.DescribeCfsFileSystemClientsRequest()
2337
+ model = models.DeleteUserQuotaRequest()
1662
2338
  model.from_json_string(json.dumps(args))
1663
2339
  start_time = time.time()
1664
2340
  while True:
1665
- rsp = client.DescribeCfsFileSystemClients(model)
2341
+ rsp = client.DeleteUserQuota(model)
1666
2342
  result = rsp.to_json_string()
1667
2343
  try:
1668
2344
  json_obj = json.loads(result)
@@ -1681,7 +2357,7 @@ def doDescribeCfsFileSystemClients(args, parsed_globals):
1681
2357
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1682
2358
 
1683
2359
 
1684
- def doDescribeBucketList(args, parsed_globals):
2360
+ def doDescribeAutoSnapshotPolicies(args, parsed_globals):
1685
2361
  g_param = parse_global_arg(parsed_globals)
1686
2362
 
1687
2363
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1710,11 +2386,11 @@ def doDescribeBucketList(args, parsed_globals):
1710
2386
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1711
2387
  client._sdkVersion += ("_CLI_" + __version__)
1712
2388
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1713
- model = models.DescribeBucketListRequest()
2389
+ model = models.DescribeAutoSnapshotPoliciesRequest()
1714
2390
  model.from_json_string(json.dumps(args))
1715
2391
  start_time = time.time()
1716
2392
  while True:
1717
- rsp = client.DescribeBucketList(model)
2393
+ rsp = client.DescribeAutoSnapshotPolicies(model)
1718
2394
  result = rsp.to_json_string()
1719
2395
  try:
1720
2396
  json_obj = json.loads(result)
@@ -1733,7 +2409,7 @@ def doDescribeBucketList(args, parsed_globals):
1733
2409
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1734
2410
 
1735
2411
 
1736
- def doCreateMigrationTask(args, parsed_globals):
2412
+ def doDeleteAutoSnapshotPolicy(args, parsed_globals):
1737
2413
  g_param = parse_global_arg(parsed_globals)
1738
2414
 
1739
2415
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1762,11 +2438,11 @@ def doCreateMigrationTask(args, parsed_globals):
1762
2438
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1763
2439
  client._sdkVersion += ("_CLI_" + __version__)
1764
2440
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1765
- model = models.CreateMigrationTaskRequest()
2441
+ model = models.DeleteAutoSnapshotPolicyRequest()
1766
2442
  model.from_json_string(json.dumps(args))
1767
2443
  start_time = time.time()
1768
2444
  while True:
1769
- rsp = client.CreateMigrationTask(model)
2445
+ rsp = client.DeleteAutoSnapshotPolicy(model)
1770
2446
  result = rsp.to_json_string()
1771
2447
  try:
1772
2448
  json_obj = json.loads(result)
@@ -1785,7 +2461,7 @@ def doCreateMigrationTask(args, parsed_globals):
1785
2461
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1786
2462
 
1787
2463
 
1788
- def doDeleteMountTarget(args, parsed_globals):
2464
+ def doStopLifecycleDataTask(args, parsed_globals):
1789
2465
  g_param = parse_global_arg(parsed_globals)
1790
2466
 
1791
2467
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1814,11 +2490,11 @@ def doDeleteMountTarget(args, parsed_globals):
1814
2490
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1815
2491
  client._sdkVersion += ("_CLI_" + __version__)
1816
2492
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1817
- model = models.DeleteMountTargetRequest()
2493
+ model = models.StopLifecycleDataTaskRequest()
1818
2494
  model.from_json_string(json.dumps(args))
1819
2495
  start_time = time.time()
1820
2496
  while True:
1821
- rsp = client.DeleteMountTarget(model)
2497
+ rsp = client.StopLifecycleDataTask(model)
1822
2498
  result = rsp.to_json_string()
1823
2499
  try:
1824
2500
  json_obj = json.loads(result)
@@ -1837,7 +2513,7 @@ def doDeleteMountTarget(args, parsed_globals):
1837
2513
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1838
2514
 
1839
2515
 
1840
- def doCreateAutoSnapshotPolicy(args, parsed_globals):
2516
+ def doCreateCfsSnapshot(args, parsed_globals):
1841
2517
  g_param = parse_global_arg(parsed_globals)
1842
2518
 
1843
2519
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1866,11 +2542,11 @@ def doCreateAutoSnapshotPolicy(args, parsed_globals):
1866
2542
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1867
2543
  client._sdkVersion += ("_CLI_" + __version__)
1868
2544
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1869
- model = models.CreateAutoSnapshotPolicyRequest()
2545
+ model = models.CreateCfsSnapshotRequest()
1870
2546
  model.from_json_string(json.dumps(args))
1871
2547
  start_time = time.time()
1872
2548
  while True:
1873
- rsp = client.CreateAutoSnapshotPolicy(model)
2549
+ rsp = client.CreateCfsSnapshot(model)
1874
2550
  result = rsp.to_json_string()
1875
2551
  try:
1876
2552
  json_obj = json.loads(result)
@@ -1889,7 +2565,7 @@ def doCreateAutoSnapshotPolicy(args, parsed_globals):
1889
2565
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1890
2566
 
1891
2567
 
1892
- def doCreateCfsPGroup(args, parsed_globals):
2568
+ def doUpdateAutoSnapshotPolicy(args, parsed_globals):
1893
2569
  g_param = parse_global_arg(parsed_globals)
1894
2570
 
1895
2571
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1918,11 +2594,11 @@ def doCreateCfsPGroup(args, parsed_globals):
1918
2594
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1919
2595
  client._sdkVersion += ("_CLI_" + __version__)
1920
2596
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1921
- model = models.CreateCfsPGroupRequest()
2597
+ model = models.UpdateAutoSnapshotPolicyRequest()
1922
2598
  model.from_json_string(json.dumps(args))
1923
2599
  start_time = time.time()
1924
2600
  while True:
1925
- rsp = client.CreateCfsPGroup(model)
2601
+ rsp = client.UpdateAutoSnapshotPolicy(model)
1926
2602
  result = rsp.to_json_string()
1927
2603
  try:
1928
2604
  json_obj = json.loads(result)
@@ -1941,7 +2617,7 @@ def doCreateCfsPGroup(args, parsed_globals):
1941
2617
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1942
2618
 
1943
2619
 
1944
- def doDeleteAutoSnapshotPolicy(args, parsed_globals):
2620
+ def doUnbindAutoSnapshotPolicy(args, parsed_globals):
1945
2621
  g_param = parse_global_arg(parsed_globals)
1946
2622
 
1947
2623
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -1970,11 +2646,11 @@ def doDeleteAutoSnapshotPolicy(args, parsed_globals):
1970
2646
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
1971
2647
  client._sdkVersion += ("_CLI_" + __version__)
1972
2648
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
1973
- model = models.DeleteAutoSnapshotPolicyRequest()
2649
+ model = models.UnbindAutoSnapshotPolicyRequest()
1974
2650
  model.from_json_string(json.dumps(args))
1975
2651
  start_time = time.time()
1976
2652
  while True:
1977
- rsp = client.DeleteAutoSnapshotPolicy(model)
2653
+ rsp = client.UnbindAutoSnapshotPolicy(model)
1978
2654
  result = rsp.to_json_string()
1979
2655
  try:
1980
2656
  json_obj = json.loads(result)
@@ -1993,7 +2669,7 @@ def doDeleteAutoSnapshotPolicy(args, parsed_globals):
1993
2669
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
1994
2670
 
1995
2671
 
1996
- def doCreateCfsSnapshot(args, parsed_globals):
2672
+ def doDescribeSnapshotOperationLogs(args, parsed_globals):
1997
2673
  g_param = parse_global_arg(parsed_globals)
1998
2674
 
1999
2675
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2022,11 +2698,11 @@ def doCreateCfsSnapshot(args, parsed_globals):
2022
2698
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
2023
2699
  client._sdkVersion += ("_CLI_" + __version__)
2024
2700
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
2025
- model = models.CreateCfsSnapshotRequest()
2701
+ model = models.DescribeSnapshotOperationLogsRequest()
2026
2702
  model.from_json_string(json.dumps(args))
2027
2703
  start_time = time.time()
2028
2704
  while True:
2029
- rsp = client.CreateCfsSnapshot(model)
2705
+ rsp = client.DescribeSnapshotOperationLogs(model)
2030
2706
  result = rsp.to_json_string()
2031
2707
  try:
2032
2708
  json_obj = json.loads(result)
@@ -2045,7 +2721,7 @@ def doCreateCfsSnapshot(args, parsed_globals):
2045
2721
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2046
2722
 
2047
2723
 
2048
- def doUnbindAutoSnapshotPolicy(args, parsed_globals):
2724
+ def doUpdateCfsFileSystemName(args, parsed_globals):
2049
2725
  g_param = parse_global_arg(parsed_globals)
2050
2726
 
2051
2727
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2074,11 +2750,11 @@ def doUnbindAutoSnapshotPolicy(args, parsed_globals):
2074
2750
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
2075
2751
  client._sdkVersion += ("_CLI_" + __version__)
2076
2752
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
2077
- model = models.UnbindAutoSnapshotPolicyRequest()
2753
+ model = models.UpdateCfsFileSystemNameRequest()
2078
2754
  model.from_json_string(json.dumps(args))
2079
2755
  start_time = time.time()
2080
2756
  while True:
2081
- rsp = client.UnbindAutoSnapshotPolicy(model)
2757
+ rsp = client.UpdateCfsFileSystemName(model)
2082
2758
  result = rsp.to_json_string()
2083
2759
  try:
2084
2760
  json_obj = json.loads(result)
@@ -2097,7 +2773,7 @@ def doUnbindAutoSnapshotPolicy(args, parsed_globals):
2097
2773
  FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
2098
2774
 
2099
2775
 
2100
- def doDescribeSnapshotOperationLogs(args, parsed_globals):
2776
+ def doDescribeDataFlow(args, parsed_globals):
2101
2777
  g_param = parse_global_arg(parsed_globals)
2102
2778
 
2103
2779
  if g_param[OptionsDefine.UseCVMRole.replace('-', '_')]:
@@ -2126,11 +2802,11 @@ def doDescribeSnapshotOperationLogs(args, parsed_globals):
2126
2802
  client = mod.CfsClient(cred, g_param[OptionsDefine.Region], profile)
2127
2803
  client._sdkVersion += ("_CLI_" + __version__)
2128
2804
  models = MODELS_MAP[g_param[OptionsDefine.Version]]
2129
- model = models.DescribeSnapshotOperationLogsRequest()
2805
+ model = models.DescribeDataFlowRequest()
2130
2806
  model.from_json_string(json.dumps(args))
2131
2807
  start_time = time.time()
2132
2808
  while True:
2133
- rsp = client.DescribeSnapshotOperationLogs(model)
2809
+ rsp = client.DescribeDataFlow(model)
2134
2810
  result = rsp.to_json_string()
2135
2811
  try:
2136
2812
  json_obj = json.loads(result)
@@ -2318,45 +2994,58 @@ MODELS_MAP = {
2318
2994
  ACTION_MAP = {
2319
2995
  "DescribeCfsRules": doDescribeCfsRules,
2320
2996
  "UpdateCfsFileSystemPGroup": doUpdateCfsFileSystemPGroup,
2321
- "SignUpCfsService": doSignUpCfsService,
2997
+ "DescribeLifecycleDataTask": doDescribeLifecycleDataTask,
2322
2998
  "DeleteCfsSnapshot": doDeleteCfsSnapshot,
2323
- "DescribeCfsPGroups": doDescribeCfsPGroups,
2324
- "UpdateFileSystemBandwidthLimit": doUpdateFileSystemBandwidthLimit,
2999
+ "UpdateCfsSnapshotAttribute": doUpdateCfsSnapshotAttribute,
2325
3000
  "SetUserQuota": doSetUserQuota,
2326
- "DescribeAutoSnapshotPolicies": doDescribeAutoSnapshotPolicies,
3001
+ "CreateCfsPGroup": doCreateCfsPGroup,
2327
3002
  "BindAutoSnapshotPolicy": doBindAutoSnapshotPolicy,
3003
+ "CreateDataFlow": doCreateDataFlow,
2328
3004
  "DeleteCfsPGroup": doDeleteCfsPGroup,
3005
+ "DeleteLifecyclePolicy": doDeleteLifecyclePolicy,
3006
+ "CreateLifecyclePolicyDownloadTask": doCreateLifecyclePolicyDownloadTask,
2329
3007
  "DeleteCfsRule": doDeleteCfsRule,
2330
3008
  "DescribeCfsServiceStatus": doDescribeCfsServiceStatus,
2331
3009
  "StopMigrationTask": doStopMigrationTask,
2332
3010
  "DescribeMigrationTasks": doDescribeMigrationTasks,
2333
3011
  "DescribeAvailableZoneInfo": doDescribeAvailableZoneInfo,
2334
- "UpdateCfsFileSystemName": doUpdateCfsFileSystemName,
2335
- "DeleteMigrationTask": doDeleteMigrationTask,
3012
+ "CreateLifecycleDataTask": doCreateLifecycleDataTask,
2336
3013
  "ScaleUpFileSystem": doScaleUpFileSystem,
3014
+ "SignUpCfsService": doSignUpCfsService,
3015
+ "CreateAutoSnapshotPolicy": doCreateAutoSnapshotPolicy,
3016
+ "DeleteMigrationTask": doDeleteMigrationTask,
3017
+ "UpdateFileSystemBandwidthLimit": doUpdateFileSystemBandwidthLimit,
2337
3018
  "UpdateCfsFileSystemSizeLimit": doUpdateCfsFileSystemSizeLimit,
2338
- "DeleteUserQuota": doDeleteUserQuota,
3019
+ "DeleteDataFlow": doDeleteDataFlow,
3020
+ "CreateLifecyclePolicy": doCreateLifecyclePolicy,
2339
3021
  "DeleteCfsFileSystem": doDeleteCfsFileSystem,
2340
3022
  "CreateCfsFileSystem": doCreateCfsFileSystem,
2341
- "UpdateCfsSnapshotAttribute": doUpdateCfsSnapshotAttribute,
3023
+ "DescribeCfsPGroups": doDescribeCfsPGroups,
2342
3024
  "DescribeCfsSnapshotOverview": doDescribeCfsSnapshotOverview,
3025
+ "DescribeLifecyclePolicies": doDescribeLifecyclePolicies,
2343
3026
  "DescribeUserQuota": doDescribeUserQuota,
3027
+ "ApplyPathLifecyclePolicy": doApplyPathLifecyclePolicy,
2344
3028
  "ModifyFileSystemAutoScaleUpRule": doModifyFileSystemAutoScaleUpRule,
2345
- "UpdateAutoSnapshotPolicy": doUpdateAutoSnapshotPolicy,
3029
+ "ModifyDataFlow": doModifyDataFlow,
2346
3030
  "CreateAccessCert": doCreateAccessCert,
2347
3031
  "DescribeCfsFileSystems": doDescribeCfsFileSystems,
2348
3032
  "DescribeCfsSnapshots": doDescribeCfsSnapshots,
2349
3033
  "DescribeMountTargets": doDescribeMountTargets,
3034
+ "ModifyLifecyclePolicy": doModifyLifecyclePolicy,
2350
3035
  "DescribeCfsFileSystemClients": doDescribeCfsFileSystemClients,
2351
3036
  "DescribeBucketList": doDescribeBucketList,
2352
3037
  "CreateMigrationTask": doCreateMigrationTask,
2353
3038
  "DeleteMountTarget": doDeleteMountTarget,
2354
- "CreateAutoSnapshotPolicy": doCreateAutoSnapshotPolicy,
2355
- "CreateCfsPGroup": doCreateCfsPGroup,
3039
+ "DeleteUserQuota": doDeleteUserQuota,
3040
+ "DescribeAutoSnapshotPolicies": doDescribeAutoSnapshotPolicies,
2356
3041
  "DeleteAutoSnapshotPolicy": doDeleteAutoSnapshotPolicy,
3042
+ "StopLifecycleDataTask": doStopLifecycleDataTask,
2357
3043
  "CreateCfsSnapshot": doCreateCfsSnapshot,
3044
+ "UpdateAutoSnapshotPolicy": doUpdateAutoSnapshotPolicy,
2358
3045
  "UnbindAutoSnapshotPolicy": doUnbindAutoSnapshotPolicy,
2359
3046
  "DescribeSnapshotOperationLogs": doDescribeSnapshotOperationLogs,
3047
+ "UpdateCfsFileSystemName": doUpdateCfsFileSystemName,
3048
+ "DescribeDataFlow": doDescribeDataFlow,
2360
3049
  "CreateCfsRule": doCreateCfsRule,
2361
3050
  "UpdateCfsRule": doUpdateCfsRule,
2362
3051
  "UpdateCfsPGroup": doUpdateCfsPGroup,