alibabacloud-cloudfw20171207 3.1.0__py3-none-any.whl → 3.3.0__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.
Potentially problematic release.
This version of alibabacloud-cloudfw20171207 might be problematic. Click here for more details.
- alibabacloud_cloudfw20171207/__init__.py +1 -1
- alibabacloud_cloudfw20171207/client.py +2368 -874
- alibabacloud_cloudfw20171207/models.py +11132 -8197
- {alibabacloud_cloudfw20171207-3.1.0.dist-info → alibabacloud_cloudfw20171207-3.3.0.dist-info}/METADATA +2 -2
- alibabacloud_cloudfw20171207-3.3.0.dist-info/RECORD +8 -0
- alibabacloud_cloudfw20171207-3.1.0.dist-info/RECORD +0 -8
- {alibabacloud_cloudfw20171207-3.1.0.dist-info → alibabacloud_cloudfw20171207-3.3.0.dist-info}/LICENSE +0 -0
- {alibabacloud_cloudfw20171207-3.1.0.dist-info → alibabacloud_cloudfw20171207-3.3.0.dist-info}/WHEEL +0 -0
- {alibabacloud_cloudfw20171207-3.1.0.dist-info → alibabacloud_cloudfw20171207-3.3.0.dist-info}/top_level.txt +0 -0
|
@@ -52,7 +52,7 @@ class Client(OpenApiClient):
|
|
|
52
52
|
) -> cloudfw_20171207_models.AddAddressBookResponse:
|
|
53
53
|
"""
|
|
54
54
|
You can call the AddAddressBook operation to create an address book for access control. The address book can be an IP address book, an ECS tag-based address book, a port address book, or a domain address book.
|
|
55
|
-
## Limits
|
|
55
|
+
## [](#qps)Limits
|
|
56
56
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
57
57
|
|
|
58
58
|
@param request: AddAddressBookRequest
|
|
@@ -105,7 +105,7 @@ class Client(OpenApiClient):
|
|
|
105
105
|
) -> cloudfw_20171207_models.AddAddressBookResponse:
|
|
106
106
|
"""
|
|
107
107
|
You can call the AddAddressBook operation to create an address book for access control. The address book can be an IP address book, an ECS tag-based address book, a port address book, or a domain address book.
|
|
108
|
-
## Limits
|
|
108
|
+
## [](#qps)Limits
|
|
109
109
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
110
110
|
|
|
111
111
|
@param request: AddAddressBookRequest
|
|
@@ -157,7 +157,7 @@ class Client(OpenApiClient):
|
|
|
157
157
|
) -> cloudfw_20171207_models.AddAddressBookResponse:
|
|
158
158
|
"""
|
|
159
159
|
You can call the AddAddressBook operation to create an address book for access control. The address book can be an IP address book, an ECS tag-based address book, a port address book, or a domain address book.
|
|
160
|
-
## Limits
|
|
160
|
+
## [](#qps)Limits
|
|
161
161
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
162
162
|
|
|
163
163
|
@param request: AddAddressBookRequest
|
|
@@ -172,7 +172,7 @@ class Client(OpenApiClient):
|
|
|
172
172
|
) -> cloudfw_20171207_models.AddAddressBookResponse:
|
|
173
173
|
"""
|
|
174
174
|
You can call the AddAddressBook operation to create an address book for access control. The address book can be an IP address book, an ECS tag-based address book, a port address book, or a domain address book.
|
|
175
|
-
## Limits
|
|
175
|
+
## [](#qps)Limits
|
|
176
176
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
177
177
|
|
|
178
178
|
@param request: AddAddressBookRequest
|
|
@@ -609,6 +609,80 @@ class Client(OpenApiClient):
|
|
|
609
609
|
runtime = util_models.RuntimeOptions()
|
|
610
610
|
return await self.batch_copy_vpc_firewall_control_policy_with_options_async(request, runtime)
|
|
611
611
|
|
|
612
|
+
def create_download_task_with_options(
|
|
613
|
+
self,
|
|
614
|
+
request: cloudfw_20171207_models.CreateDownloadTaskRequest,
|
|
615
|
+
runtime: util_models.RuntimeOptions,
|
|
616
|
+
) -> cloudfw_20171207_models.CreateDownloadTaskResponse:
|
|
617
|
+
UtilClient.validate_model(request)
|
|
618
|
+
query = {}
|
|
619
|
+
if not UtilClient.is_unset(request.lang):
|
|
620
|
+
query['Lang'] = request.lang
|
|
621
|
+
if not UtilClient.is_unset(request.task_data):
|
|
622
|
+
query['TaskData'] = request.task_data
|
|
623
|
+
req = open_api_models.OpenApiRequest(
|
|
624
|
+
query=OpenApiUtilClient.query(query)
|
|
625
|
+
)
|
|
626
|
+
params = open_api_models.Params(
|
|
627
|
+
action='CreateDownloadTask',
|
|
628
|
+
version='2017-12-07',
|
|
629
|
+
protocol='HTTPS',
|
|
630
|
+
pathname='/',
|
|
631
|
+
method='POST',
|
|
632
|
+
auth_type='AK',
|
|
633
|
+
style='RPC',
|
|
634
|
+
req_body_type='formData',
|
|
635
|
+
body_type='json'
|
|
636
|
+
)
|
|
637
|
+
return TeaCore.from_map(
|
|
638
|
+
cloudfw_20171207_models.CreateDownloadTaskResponse(),
|
|
639
|
+
self.call_api(params, req, runtime)
|
|
640
|
+
)
|
|
641
|
+
|
|
642
|
+
async def create_download_task_with_options_async(
|
|
643
|
+
self,
|
|
644
|
+
request: cloudfw_20171207_models.CreateDownloadTaskRequest,
|
|
645
|
+
runtime: util_models.RuntimeOptions,
|
|
646
|
+
) -> cloudfw_20171207_models.CreateDownloadTaskResponse:
|
|
647
|
+
UtilClient.validate_model(request)
|
|
648
|
+
query = {}
|
|
649
|
+
if not UtilClient.is_unset(request.lang):
|
|
650
|
+
query['Lang'] = request.lang
|
|
651
|
+
if not UtilClient.is_unset(request.task_data):
|
|
652
|
+
query['TaskData'] = request.task_data
|
|
653
|
+
req = open_api_models.OpenApiRequest(
|
|
654
|
+
query=OpenApiUtilClient.query(query)
|
|
655
|
+
)
|
|
656
|
+
params = open_api_models.Params(
|
|
657
|
+
action='CreateDownloadTask',
|
|
658
|
+
version='2017-12-07',
|
|
659
|
+
protocol='HTTPS',
|
|
660
|
+
pathname='/',
|
|
661
|
+
method='POST',
|
|
662
|
+
auth_type='AK',
|
|
663
|
+
style='RPC',
|
|
664
|
+
req_body_type='formData',
|
|
665
|
+
body_type='json'
|
|
666
|
+
)
|
|
667
|
+
return TeaCore.from_map(
|
|
668
|
+
cloudfw_20171207_models.CreateDownloadTaskResponse(),
|
|
669
|
+
await self.call_api_async(params, req, runtime)
|
|
670
|
+
)
|
|
671
|
+
|
|
672
|
+
def create_download_task(
|
|
673
|
+
self,
|
|
674
|
+
request: cloudfw_20171207_models.CreateDownloadTaskRequest,
|
|
675
|
+
) -> cloudfw_20171207_models.CreateDownloadTaskResponse:
|
|
676
|
+
runtime = util_models.RuntimeOptions()
|
|
677
|
+
return self.create_download_task_with_options(request, runtime)
|
|
678
|
+
|
|
679
|
+
async def create_download_task_async(
|
|
680
|
+
self,
|
|
681
|
+
request: cloudfw_20171207_models.CreateDownloadTaskRequest,
|
|
682
|
+
) -> cloudfw_20171207_models.CreateDownloadTaskResponse:
|
|
683
|
+
runtime = util_models.RuntimeOptions()
|
|
684
|
+
return await self.create_download_task_with_options_async(request, runtime)
|
|
685
|
+
|
|
612
686
|
def create_nat_firewall_control_policy_with_options(
|
|
613
687
|
self,
|
|
614
688
|
request: cloudfw_20171207_models.CreateNatFirewallControlPolicyRequest,
|
|
@@ -1733,6 +1807,162 @@ class Client(OpenApiClient):
|
|
|
1733
1807
|
runtime = util_models.RuntimeOptions()
|
|
1734
1808
|
return await self.delete_control_policy_with_options_async(request, runtime)
|
|
1735
1809
|
|
|
1810
|
+
def delete_control_policy_template_with_options(
|
|
1811
|
+
self,
|
|
1812
|
+
request: cloudfw_20171207_models.DeleteControlPolicyTemplateRequest,
|
|
1813
|
+
runtime: util_models.RuntimeOptions,
|
|
1814
|
+
) -> cloudfw_20171207_models.DeleteControlPolicyTemplateResponse:
|
|
1815
|
+
UtilClient.validate_model(request)
|
|
1816
|
+
query = {}
|
|
1817
|
+
if not UtilClient.is_unset(request.lang):
|
|
1818
|
+
query['Lang'] = request.lang
|
|
1819
|
+
if not UtilClient.is_unset(request.lang):
|
|
1820
|
+
query['Lang'] = request.lang
|
|
1821
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
1822
|
+
query['SourceIp'] = request.source_ip
|
|
1823
|
+
if not UtilClient.is_unset(request.template_id):
|
|
1824
|
+
query['TemplateId'] = request.template_id
|
|
1825
|
+
req = open_api_models.OpenApiRequest(
|
|
1826
|
+
query=OpenApiUtilClient.query(query)
|
|
1827
|
+
)
|
|
1828
|
+
params = open_api_models.Params(
|
|
1829
|
+
action='DeleteControlPolicyTemplate',
|
|
1830
|
+
version='2017-12-07',
|
|
1831
|
+
protocol='HTTPS',
|
|
1832
|
+
pathname='/',
|
|
1833
|
+
method='POST',
|
|
1834
|
+
auth_type='AK',
|
|
1835
|
+
style='RPC',
|
|
1836
|
+
req_body_type='formData',
|
|
1837
|
+
body_type='json'
|
|
1838
|
+
)
|
|
1839
|
+
return TeaCore.from_map(
|
|
1840
|
+
cloudfw_20171207_models.DeleteControlPolicyTemplateResponse(),
|
|
1841
|
+
self.call_api(params, req, runtime)
|
|
1842
|
+
)
|
|
1843
|
+
|
|
1844
|
+
async def delete_control_policy_template_with_options_async(
|
|
1845
|
+
self,
|
|
1846
|
+
request: cloudfw_20171207_models.DeleteControlPolicyTemplateRequest,
|
|
1847
|
+
runtime: util_models.RuntimeOptions,
|
|
1848
|
+
) -> cloudfw_20171207_models.DeleteControlPolicyTemplateResponse:
|
|
1849
|
+
UtilClient.validate_model(request)
|
|
1850
|
+
query = {}
|
|
1851
|
+
if not UtilClient.is_unset(request.lang):
|
|
1852
|
+
query['Lang'] = request.lang
|
|
1853
|
+
if not UtilClient.is_unset(request.lang):
|
|
1854
|
+
query['Lang'] = request.lang
|
|
1855
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
1856
|
+
query['SourceIp'] = request.source_ip
|
|
1857
|
+
if not UtilClient.is_unset(request.template_id):
|
|
1858
|
+
query['TemplateId'] = request.template_id
|
|
1859
|
+
req = open_api_models.OpenApiRequest(
|
|
1860
|
+
query=OpenApiUtilClient.query(query)
|
|
1861
|
+
)
|
|
1862
|
+
params = open_api_models.Params(
|
|
1863
|
+
action='DeleteControlPolicyTemplate',
|
|
1864
|
+
version='2017-12-07',
|
|
1865
|
+
protocol='HTTPS',
|
|
1866
|
+
pathname='/',
|
|
1867
|
+
method='POST',
|
|
1868
|
+
auth_type='AK',
|
|
1869
|
+
style='RPC',
|
|
1870
|
+
req_body_type='formData',
|
|
1871
|
+
body_type='json'
|
|
1872
|
+
)
|
|
1873
|
+
return TeaCore.from_map(
|
|
1874
|
+
cloudfw_20171207_models.DeleteControlPolicyTemplateResponse(),
|
|
1875
|
+
await self.call_api_async(params, req, runtime)
|
|
1876
|
+
)
|
|
1877
|
+
|
|
1878
|
+
def delete_control_policy_template(
|
|
1879
|
+
self,
|
|
1880
|
+
request: cloudfw_20171207_models.DeleteControlPolicyTemplateRequest,
|
|
1881
|
+
) -> cloudfw_20171207_models.DeleteControlPolicyTemplateResponse:
|
|
1882
|
+
runtime = util_models.RuntimeOptions()
|
|
1883
|
+
return self.delete_control_policy_template_with_options(request, runtime)
|
|
1884
|
+
|
|
1885
|
+
async def delete_control_policy_template_async(
|
|
1886
|
+
self,
|
|
1887
|
+
request: cloudfw_20171207_models.DeleteControlPolicyTemplateRequest,
|
|
1888
|
+
) -> cloudfw_20171207_models.DeleteControlPolicyTemplateResponse:
|
|
1889
|
+
runtime = util_models.RuntimeOptions()
|
|
1890
|
+
return await self.delete_control_policy_template_with_options_async(request, runtime)
|
|
1891
|
+
|
|
1892
|
+
def delete_download_task_with_options(
|
|
1893
|
+
self,
|
|
1894
|
+
request: cloudfw_20171207_models.DeleteDownloadTaskRequest,
|
|
1895
|
+
runtime: util_models.RuntimeOptions,
|
|
1896
|
+
) -> cloudfw_20171207_models.DeleteDownloadTaskResponse:
|
|
1897
|
+
UtilClient.validate_model(request)
|
|
1898
|
+
query = {}
|
|
1899
|
+
if not UtilClient.is_unset(request.lang):
|
|
1900
|
+
query['Lang'] = request.lang
|
|
1901
|
+
if not UtilClient.is_unset(request.task_id):
|
|
1902
|
+
query['TaskId'] = request.task_id
|
|
1903
|
+
req = open_api_models.OpenApiRequest(
|
|
1904
|
+
query=OpenApiUtilClient.query(query)
|
|
1905
|
+
)
|
|
1906
|
+
params = open_api_models.Params(
|
|
1907
|
+
action='DeleteDownloadTask',
|
|
1908
|
+
version='2017-12-07',
|
|
1909
|
+
protocol='HTTPS',
|
|
1910
|
+
pathname='/',
|
|
1911
|
+
method='POST',
|
|
1912
|
+
auth_type='AK',
|
|
1913
|
+
style='RPC',
|
|
1914
|
+
req_body_type='formData',
|
|
1915
|
+
body_type='json'
|
|
1916
|
+
)
|
|
1917
|
+
return TeaCore.from_map(
|
|
1918
|
+
cloudfw_20171207_models.DeleteDownloadTaskResponse(),
|
|
1919
|
+
self.call_api(params, req, runtime)
|
|
1920
|
+
)
|
|
1921
|
+
|
|
1922
|
+
async def delete_download_task_with_options_async(
|
|
1923
|
+
self,
|
|
1924
|
+
request: cloudfw_20171207_models.DeleteDownloadTaskRequest,
|
|
1925
|
+
runtime: util_models.RuntimeOptions,
|
|
1926
|
+
) -> cloudfw_20171207_models.DeleteDownloadTaskResponse:
|
|
1927
|
+
UtilClient.validate_model(request)
|
|
1928
|
+
query = {}
|
|
1929
|
+
if not UtilClient.is_unset(request.lang):
|
|
1930
|
+
query['Lang'] = request.lang
|
|
1931
|
+
if not UtilClient.is_unset(request.task_id):
|
|
1932
|
+
query['TaskId'] = request.task_id
|
|
1933
|
+
req = open_api_models.OpenApiRequest(
|
|
1934
|
+
query=OpenApiUtilClient.query(query)
|
|
1935
|
+
)
|
|
1936
|
+
params = open_api_models.Params(
|
|
1937
|
+
action='DeleteDownloadTask',
|
|
1938
|
+
version='2017-12-07',
|
|
1939
|
+
protocol='HTTPS',
|
|
1940
|
+
pathname='/',
|
|
1941
|
+
method='POST',
|
|
1942
|
+
auth_type='AK',
|
|
1943
|
+
style='RPC',
|
|
1944
|
+
req_body_type='formData',
|
|
1945
|
+
body_type='json'
|
|
1946
|
+
)
|
|
1947
|
+
return TeaCore.from_map(
|
|
1948
|
+
cloudfw_20171207_models.DeleteDownloadTaskResponse(),
|
|
1949
|
+
await self.call_api_async(params, req, runtime)
|
|
1950
|
+
)
|
|
1951
|
+
|
|
1952
|
+
def delete_download_task(
|
|
1953
|
+
self,
|
|
1954
|
+
request: cloudfw_20171207_models.DeleteDownloadTaskRequest,
|
|
1955
|
+
) -> cloudfw_20171207_models.DeleteDownloadTaskResponse:
|
|
1956
|
+
runtime = util_models.RuntimeOptions()
|
|
1957
|
+
return self.delete_download_task_with_options(request, runtime)
|
|
1958
|
+
|
|
1959
|
+
async def delete_download_task_async(
|
|
1960
|
+
self,
|
|
1961
|
+
request: cloudfw_20171207_models.DeleteDownloadTaskRequest,
|
|
1962
|
+
) -> cloudfw_20171207_models.DeleteDownloadTaskResponse:
|
|
1963
|
+
runtime = util_models.RuntimeOptions()
|
|
1964
|
+
return await self.delete_download_task_with_options_async(request, runtime)
|
|
1965
|
+
|
|
1736
1966
|
def delete_firewall_v2route_policies_with_options(
|
|
1737
1967
|
self,
|
|
1738
1968
|
request: cloudfw_20171207_models.DeleteFirewallV2RoutePoliciesRequest,
|
|
@@ -2023,6 +2253,88 @@ class Client(OpenApiClient):
|
|
|
2023
2253
|
runtime = util_models.RuntimeOptions()
|
|
2024
2254
|
return await self.delete_nat_firewall_control_policy_with_options_async(request, runtime)
|
|
2025
2255
|
|
|
2256
|
+
def delete_nat_firewall_control_policy_batch_with_options(
|
|
2257
|
+
self,
|
|
2258
|
+
request: cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchRequest,
|
|
2259
|
+
runtime: util_models.RuntimeOptions,
|
|
2260
|
+
) -> cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchResponse:
|
|
2261
|
+
UtilClient.validate_model(request)
|
|
2262
|
+
query = {}
|
|
2263
|
+
if not UtilClient.is_unset(request.acl_uuid_list):
|
|
2264
|
+
query['AclUuidList'] = request.acl_uuid_list
|
|
2265
|
+
if not UtilClient.is_unset(request.direction):
|
|
2266
|
+
query['Direction'] = request.direction
|
|
2267
|
+
if not UtilClient.is_unset(request.lang):
|
|
2268
|
+
query['Lang'] = request.lang
|
|
2269
|
+
if not UtilClient.is_unset(request.nat_gateway_id):
|
|
2270
|
+
query['NatGatewayId'] = request.nat_gateway_id
|
|
2271
|
+
req = open_api_models.OpenApiRequest(
|
|
2272
|
+
query=OpenApiUtilClient.query(query)
|
|
2273
|
+
)
|
|
2274
|
+
params = open_api_models.Params(
|
|
2275
|
+
action='DeleteNatFirewallControlPolicyBatch',
|
|
2276
|
+
version='2017-12-07',
|
|
2277
|
+
protocol='HTTPS',
|
|
2278
|
+
pathname='/',
|
|
2279
|
+
method='POST',
|
|
2280
|
+
auth_type='AK',
|
|
2281
|
+
style='RPC',
|
|
2282
|
+
req_body_type='formData',
|
|
2283
|
+
body_type='json'
|
|
2284
|
+
)
|
|
2285
|
+
return TeaCore.from_map(
|
|
2286
|
+
cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchResponse(),
|
|
2287
|
+
self.call_api(params, req, runtime)
|
|
2288
|
+
)
|
|
2289
|
+
|
|
2290
|
+
async def delete_nat_firewall_control_policy_batch_with_options_async(
|
|
2291
|
+
self,
|
|
2292
|
+
request: cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchRequest,
|
|
2293
|
+
runtime: util_models.RuntimeOptions,
|
|
2294
|
+
) -> cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchResponse:
|
|
2295
|
+
UtilClient.validate_model(request)
|
|
2296
|
+
query = {}
|
|
2297
|
+
if not UtilClient.is_unset(request.acl_uuid_list):
|
|
2298
|
+
query['AclUuidList'] = request.acl_uuid_list
|
|
2299
|
+
if not UtilClient.is_unset(request.direction):
|
|
2300
|
+
query['Direction'] = request.direction
|
|
2301
|
+
if not UtilClient.is_unset(request.lang):
|
|
2302
|
+
query['Lang'] = request.lang
|
|
2303
|
+
if not UtilClient.is_unset(request.nat_gateway_id):
|
|
2304
|
+
query['NatGatewayId'] = request.nat_gateway_id
|
|
2305
|
+
req = open_api_models.OpenApiRequest(
|
|
2306
|
+
query=OpenApiUtilClient.query(query)
|
|
2307
|
+
)
|
|
2308
|
+
params = open_api_models.Params(
|
|
2309
|
+
action='DeleteNatFirewallControlPolicyBatch',
|
|
2310
|
+
version='2017-12-07',
|
|
2311
|
+
protocol='HTTPS',
|
|
2312
|
+
pathname='/',
|
|
2313
|
+
method='POST',
|
|
2314
|
+
auth_type='AK',
|
|
2315
|
+
style='RPC',
|
|
2316
|
+
req_body_type='formData',
|
|
2317
|
+
body_type='json'
|
|
2318
|
+
)
|
|
2319
|
+
return TeaCore.from_map(
|
|
2320
|
+
cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchResponse(),
|
|
2321
|
+
await self.call_api_async(params, req, runtime)
|
|
2322
|
+
)
|
|
2323
|
+
|
|
2324
|
+
def delete_nat_firewall_control_policy_batch(
|
|
2325
|
+
self,
|
|
2326
|
+
request: cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchRequest,
|
|
2327
|
+
) -> cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchResponse:
|
|
2328
|
+
runtime = util_models.RuntimeOptions()
|
|
2329
|
+
return self.delete_nat_firewall_control_policy_batch_with_options(request, runtime)
|
|
2330
|
+
|
|
2331
|
+
async def delete_nat_firewall_control_policy_batch_async(
|
|
2332
|
+
self,
|
|
2333
|
+
request: cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchRequest,
|
|
2334
|
+
) -> cloudfw_20171207_models.DeleteNatFirewallControlPolicyBatchResponse:
|
|
2335
|
+
runtime = util_models.RuntimeOptions()
|
|
2336
|
+
return await self.delete_nat_firewall_control_policy_batch_with_options_async(request, runtime)
|
|
2337
|
+
|
|
2026
2338
|
def delete_tr_firewall_v2with_options(
|
|
2027
2339
|
self,
|
|
2028
2340
|
request: cloudfw_20171207_models.DeleteTrFirewallV2Request,
|
|
@@ -2215,7 +2527,7 @@ class Client(OpenApiClient):
|
|
|
2215
2527
|
runtime: util_models.RuntimeOptions,
|
|
2216
2528
|
) -> cloudfw_20171207_models.DeleteVpcFirewallConfigureResponse:
|
|
2217
2529
|
"""
|
|
2218
|
-
You can call the
|
|
2530
|
+
You can call the DeleteVpcFirewallConfigure operation to delete a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
2219
2531
|
## Limits
|
|
2220
2532
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2221
2533
|
|
|
@@ -2256,7 +2568,7 @@ class Client(OpenApiClient):
|
|
|
2256
2568
|
runtime: util_models.RuntimeOptions,
|
|
2257
2569
|
) -> cloudfw_20171207_models.DeleteVpcFirewallConfigureResponse:
|
|
2258
2570
|
"""
|
|
2259
|
-
You can call the
|
|
2571
|
+
You can call the DeleteVpcFirewallConfigure operation to delete a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
2260
2572
|
## Limits
|
|
2261
2573
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2262
2574
|
|
|
@@ -2296,7 +2608,7 @@ class Client(OpenApiClient):
|
|
|
2296
2608
|
request: cloudfw_20171207_models.DeleteVpcFirewallConfigureRequest,
|
|
2297
2609
|
) -> cloudfw_20171207_models.DeleteVpcFirewallConfigureResponse:
|
|
2298
2610
|
"""
|
|
2299
|
-
You can call the
|
|
2611
|
+
You can call the DeleteVpcFirewallConfigure operation to delete a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
2300
2612
|
## Limits
|
|
2301
2613
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2302
2614
|
|
|
@@ -2311,7 +2623,7 @@ class Client(OpenApiClient):
|
|
|
2311
2623
|
request: cloudfw_20171207_models.DeleteVpcFirewallConfigureRequest,
|
|
2312
2624
|
) -> cloudfw_20171207_models.DeleteVpcFirewallConfigureResponse:
|
|
2313
2625
|
"""
|
|
2314
|
-
You can call the
|
|
2626
|
+
You can call the DeleteVpcFirewallConfigure operation to delete a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
2315
2627
|
## Limits
|
|
2316
2628
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2317
2629
|
|
|
@@ -2525,8 +2837,8 @@ class Client(OpenApiClient):
|
|
|
2525
2837
|
runtime: util_models.RuntimeOptions,
|
|
2526
2838
|
) -> cloudfw_20171207_models.DescribeAddressBookResponse:
|
|
2527
2839
|
"""
|
|
2528
|
-
You can call
|
|
2529
|
-
## Limits
|
|
2840
|
+
You can call this operation to query the details about an address book for an access control policy.
|
|
2841
|
+
## [](#qps)Limits
|
|
2530
2842
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2531
2843
|
|
|
2532
2844
|
@param request: DescribeAddressBookRequest
|
|
@@ -2572,8 +2884,8 @@ class Client(OpenApiClient):
|
|
|
2572
2884
|
runtime: util_models.RuntimeOptions,
|
|
2573
2885
|
) -> cloudfw_20171207_models.DescribeAddressBookResponse:
|
|
2574
2886
|
"""
|
|
2575
|
-
You can call
|
|
2576
|
-
## Limits
|
|
2887
|
+
You can call this operation to query the details about an address book for an access control policy.
|
|
2888
|
+
## [](#qps)Limits
|
|
2577
2889
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2578
2890
|
|
|
2579
2891
|
@param request: DescribeAddressBookRequest
|
|
@@ -2618,8 +2930,8 @@ class Client(OpenApiClient):
|
|
|
2618
2930
|
request: cloudfw_20171207_models.DescribeAddressBookRequest,
|
|
2619
2931
|
) -> cloudfw_20171207_models.DescribeAddressBookResponse:
|
|
2620
2932
|
"""
|
|
2621
|
-
You can call
|
|
2622
|
-
## Limits
|
|
2933
|
+
You can call this operation to query the details about an address book for an access control policy.
|
|
2934
|
+
## [](#qps)Limits
|
|
2623
2935
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2624
2936
|
|
|
2625
2937
|
@param request: DescribeAddressBookRequest
|
|
@@ -2633,8 +2945,8 @@ class Client(OpenApiClient):
|
|
|
2633
2945
|
request: cloudfw_20171207_models.DescribeAddressBookRequest,
|
|
2634
2946
|
) -> cloudfw_20171207_models.DescribeAddressBookResponse:
|
|
2635
2947
|
"""
|
|
2636
|
-
You can call
|
|
2637
|
-
## Limits
|
|
2948
|
+
You can call this operation to query the details about an address book for an access control policy.
|
|
2949
|
+
## [](#qps)Limits
|
|
2638
2950
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2639
2951
|
|
|
2640
2952
|
@param request: DescribeAddressBookRequest
|
|
@@ -2795,34 +3107,194 @@ class Client(OpenApiClient):
|
|
|
2795
3107
|
runtime = util_models.RuntimeOptions()
|
|
2796
3108
|
return await self.describe_asset_list_with_options_async(request, runtime)
|
|
2797
3109
|
|
|
2798
|
-
def
|
|
3110
|
+
def describe_asset_risk_list_with_options(
|
|
2799
3111
|
self,
|
|
2800
|
-
request: cloudfw_20171207_models.
|
|
3112
|
+
request: cloudfw_20171207_models.DescribeAssetRiskListRequest,
|
|
2801
3113
|
runtime: util_models.RuntimeOptions,
|
|
2802
|
-
) -> cloudfw_20171207_models.
|
|
2803
|
-
"""
|
|
2804
|
-
You can call the DescribeControlPolicy operation to query the details about access control policies by page.
|
|
2805
|
-
## Limits
|
|
2806
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
2807
|
-
|
|
2808
|
-
@param request: DescribeControlPolicyRequest
|
|
2809
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
2810
|
-
@return: DescribeControlPolicyResponse
|
|
2811
|
-
"""
|
|
3114
|
+
) -> cloudfw_20171207_models.DescribeAssetRiskListResponse:
|
|
2812
3115
|
UtilClient.validate_model(request)
|
|
2813
3116
|
query = {}
|
|
2814
|
-
if not UtilClient.is_unset(request.
|
|
2815
|
-
query['
|
|
2816
|
-
if not UtilClient.is_unset(request.
|
|
2817
|
-
query['
|
|
2818
|
-
if not UtilClient.is_unset(request.
|
|
2819
|
-
query['
|
|
2820
|
-
if not UtilClient.is_unset(request.
|
|
2821
|
-
query['
|
|
2822
|
-
|
|
2823
|
-
query
|
|
2824
|
-
|
|
2825
|
-
|
|
3117
|
+
if not UtilClient.is_unset(request.ip_addr_list):
|
|
3118
|
+
query['IpAddrList'] = request.ip_addr_list
|
|
3119
|
+
if not UtilClient.is_unset(request.ip_version):
|
|
3120
|
+
query['IpVersion'] = request.ip_version
|
|
3121
|
+
if not UtilClient.is_unset(request.lang):
|
|
3122
|
+
query['Lang'] = request.lang
|
|
3123
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
3124
|
+
query['SourceIp'] = request.source_ip
|
|
3125
|
+
req = open_api_models.OpenApiRequest(
|
|
3126
|
+
query=OpenApiUtilClient.query(query)
|
|
3127
|
+
)
|
|
3128
|
+
params = open_api_models.Params(
|
|
3129
|
+
action='DescribeAssetRiskList',
|
|
3130
|
+
version='2017-12-07',
|
|
3131
|
+
protocol='HTTPS',
|
|
3132
|
+
pathname='/',
|
|
3133
|
+
method='POST',
|
|
3134
|
+
auth_type='AK',
|
|
3135
|
+
style='RPC',
|
|
3136
|
+
req_body_type='formData',
|
|
3137
|
+
body_type='json'
|
|
3138
|
+
)
|
|
3139
|
+
return TeaCore.from_map(
|
|
3140
|
+
cloudfw_20171207_models.DescribeAssetRiskListResponse(),
|
|
3141
|
+
self.call_api(params, req, runtime)
|
|
3142
|
+
)
|
|
3143
|
+
|
|
3144
|
+
async def describe_asset_risk_list_with_options_async(
|
|
3145
|
+
self,
|
|
3146
|
+
request: cloudfw_20171207_models.DescribeAssetRiskListRequest,
|
|
3147
|
+
runtime: util_models.RuntimeOptions,
|
|
3148
|
+
) -> cloudfw_20171207_models.DescribeAssetRiskListResponse:
|
|
3149
|
+
UtilClient.validate_model(request)
|
|
3150
|
+
query = {}
|
|
3151
|
+
if not UtilClient.is_unset(request.ip_addr_list):
|
|
3152
|
+
query['IpAddrList'] = request.ip_addr_list
|
|
3153
|
+
if not UtilClient.is_unset(request.ip_version):
|
|
3154
|
+
query['IpVersion'] = request.ip_version
|
|
3155
|
+
if not UtilClient.is_unset(request.lang):
|
|
3156
|
+
query['Lang'] = request.lang
|
|
3157
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
3158
|
+
query['SourceIp'] = request.source_ip
|
|
3159
|
+
req = open_api_models.OpenApiRequest(
|
|
3160
|
+
query=OpenApiUtilClient.query(query)
|
|
3161
|
+
)
|
|
3162
|
+
params = open_api_models.Params(
|
|
3163
|
+
action='DescribeAssetRiskList',
|
|
3164
|
+
version='2017-12-07',
|
|
3165
|
+
protocol='HTTPS',
|
|
3166
|
+
pathname='/',
|
|
3167
|
+
method='POST',
|
|
3168
|
+
auth_type='AK',
|
|
3169
|
+
style='RPC',
|
|
3170
|
+
req_body_type='formData',
|
|
3171
|
+
body_type='json'
|
|
3172
|
+
)
|
|
3173
|
+
return TeaCore.from_map(
|
|
3174
|
+
cloudfw_20171207_models.DescribeAssetRiskListResponse(),
|
|
3175
|
+
await self.call_api_async(params, req, runtime)
|
|
3176
|
+
)
|
|
3177
|
+
|
|
3178
|
+
def describe_asset_risk_list(
|
|
3179
|
+
self,
|
|
3180
|
+
request: cloudfw_20171207_models.DescribeAssetRiskListRequest,
|
|
3181
|
+
) -> cloudfw_20171207_models.DescribeAssetRiskListResponse:
|
|
3182
|
+
runtime = util_models.RuntimeOptions()
|
|
3183
|
+
return self.describe_asset_risk_list_with_options(request, runtime)
|
|
3184
|
+
|
|
3185
|
+
async def describe_asset_risk_list_async(
|
|
3186
|
+
self,
|
|
3187
|
+
request: cloudfw_20171207_models.DescribeAssetRiskListRequest,
|
|
3188
|
+
) -> cloudfw_20171207_models.DescribeAssetRiskListResponse:
|
|
3189
|
+
runtime = util_models.RuntimeOptions()
|
|
3190
|
+
return await self.describe_asset_risk_list_with_options_async(request, runtime)
|
|
3191
|
+
|
|
3192
|
+
def describe_cfw_risk_level_summary_with_options(
|
|
3193
|
+
self,
|
|
3194
|
+
request: cloudfw_20171207_models.DescribeCfwRiskLevelSummaryRequest,
|
|
3195
|
+
runtime: util_models.RuntimeOptions,
|
|
3196
|
+
) -> cloudfw_20171207_models.DescribeCfwRiskLevelSummaryResponse:
|
|
3197
|
+
UtilClient.validate_model(request)
|
|
3198
|
+
query = {}
|
|
3199
|
+
if not UtilClient.is_unset(request.instance_type):
|
|
3200
|
+
query['InstanceType'] = request.instance_type
|
|
3201
|
+
if not UtilClient.is_unset(request.lang):
|
|
3202
|
+
query['Lang'] = request.lang
|
|
3203
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3204
|
+
query['RegionId'] = request.region_id
|
|
3205
|
+
req = open_api_models.OpenApiRequest(
|
|
3206
|
+
query=OpenApiUtilClient.query(query)
|
|
3207
|
+
)
|
|
3208
|
+
params = open_api_models.Params(
|
|
3209
|
+
action='DescribeCfwRiskLevelSummary',
|
|
3210
|
+
version='2017-12-07',
|
|
3211
|
+
protocol='HTTPS',
|
|
3212
|
+
pathname='/',
|
|
3213
|
+
method='POST',
|
|
3214
|
+
auth_type='AK',
|
|
3215
|
+
style='RPC',
|
|
3216
|
+
req_body_type='formData',
|
|
3217
|
+
body_type='json'
|
|
3218
|
+
)
|
|
3219
|
+
return TeaCore.from_map(
|
|
3220
|
+
cloudfw_20171207_models.DescribeCfwRiskLevelSummaryResponse(),
|
|
3221
|
+
self.call_api(params, req, runtime)
|
|
3222
|
+
)
|
|
3223
|
+
|
|
3224
|
+
async def describe_cfw_risk_level_summary_with_options_async(
|
|
3225
|
+
self,
|
|
3226
|
+
request: cloudfw_20171207_models.DescribeCfwRiskLevelSummaryRequest,
|
|
3227
|
+
runtime: util_models.RuntimeOptions,
|
|
3228
|
+
) -> cloudfw_20171207_models.DescribeCfwRiskLevelSummaryResponse:
|
|
3229
|
+
UtilClient.validate_model(request)
|
|
3230
|
+
query = {}
|
|
3231
|
+
if not UtilClient.is_unset(request.instance_type):
|
|
3232
|
+
query['InstanceType'] = request.instance_type
|
|
3233
|
+
if not UtilClient.is_unset(request.lang):
|
|
3234
|
+
query['Lang'] = request.lang
|
|
3235
|
+
if not UtilClient.is_unset(request.region_id):
|
|
3236
|
+
query['RegionId'] = request.region_id
|
|
3237
|
+
req = open_api_models.OpenApiRequest(
|
|
3238
|
+
query=OpenApiUtilClient.query(query)
|
|
3239
|
+
)
|
|
3240
|
+
params = open_api_models.Params(
|
|
3241
|
+
action='DescribeCfwRiskLevelSummary',
|
|
3242
|
+
version='2017-12-07',
|
|
3243
|
+
protocol='HTTPS',
|
|
3244
|
+
pathname='/',
|
|
3245
|
+
method='POST',
|
|
3246
|
+
auth_type='AK',
|
|
3247
|
+
style='RPC',
|
|
3248
|
+
req_body_type='formData',
|
|
3249
|
+
body_type='json'
|
|
3250
|
+
)
|
|
3251
|
+
return TeaCore.from_map(
|
|
3252
|
+
cloudfw_20171207_models.DescribeCfwRiskLevelSummaryResponse(),
|
|
3253
|
+
await self.call_api_async(params, req, runtime)
|
|
3254
|
+
)
|
|
3255
|
+
|
|
3256
|
+
def describe_cfw_risk_level_summary(
|
|
3257
|
+
self,
|
|
3258
|
+
request: cloudfw_20171207_models.DescribeCfwRiskLevelSummaryRequest,
|
|
3259
|
+
) -> cloudfw_20171207_models.DescribeCfwRiskLevelSummaryResponse:
|
|
3260
|
+
runtime = util_models.RuntimeOptions()
|
|
3261
|
+
return self.describe_cfw_risk_level_summary_with_options(request, runtime)
|
|
3262
|
+
|
|
3263
|
+
async def describe_cfw_risk_level_summary_async(
|
|
3264
|
+
self,
|
|
3265
|
+
request: cloudfw_20171207_models.DescribeCfwRiskLevelSummaryRequest,
|
|
3266
|
+
) -> cloudfw_20171207_models.DescribeCfwRiskLevelSummaryResponse:
|
|
3267
|
+
runtime = util_models.RuntimeOptions()
|
|
3268
|
+
return await self.describe_cfw_risk_level_summary_with_options_async(request, runtime)
|
|
3269
|
+
|
|
3270
|
+
def describe_control_policy_with_options(
|
|
3271
|
+
self,
|
|
3272
|
+
request: cloudfw_20171207_models.DescribeControlPolicyRequest,
|
|
3273
|
+
runtime: util_models.RuntimeOptions,
|
|
3274
|
+
) -> cloudfw_20171207_models.DescribeControlPolicyResponse:
|
|
3275
|
+
"""
|
|
3276
|
+
You can call the DescribeControlPolicy operation to query the details about access control policies by page.
|
|
3277
|
+
## Limits
|
|
3278
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
3279
|
+
|
|
3280
|
+
@param request: DescribeControlPolicyRequest
|
|
3281
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
3282
|
+
@return: DescribeControlPolicyResponse
|
|
3283
|
+
"""
|
|
3284
|
+
UtilClient.validate_model(request)
|
|
3285
|
+
query = {}
|
|
3286
|
+
if not UtilClient.is_unset(request.acl_action):
|
|
3287
|
+
query['AclAction'] = request.acl_action
|
|
3288
|
+
if not UtilClient.is_unset(request.acl_uuid):
|
|
3289
|
+
query['AclUuid'] = request.acl_uuid
|
|
3290
|
+
if not UtilClient.is_unset(request.current_page):
|
|
3291
|
+
query['CurrentPage'] = request.current_page
|
|
3292
|
+
if not UtilClient.is_unset(request.description):
|
|
3293
|
+
query['Description'] = request.description
|
|
3294
|
+
if not UtilClient.is_unset(request.destination):
|
|
3295
|
+
query['Destination'] = request.destination
|
|
3296
|
+
if not UtilClient.is_unset(request.direction):
|
|
3297
|
+
query['Direction'] = request.direction
|
|
2826
3298
|
if not UtilClient.is_unset(request.ip_version):
|
|
2827
3299
|
query['IpVersion'] = request.ip_version
|
|
2828
3300
|
if not UtilClient.is_unset(request.lang):
|
|
@@ -3145,6 +3617,170 @@ class Client(OpenApiClient):
|
|
|
3145
3617
|
runtime = util_models.RuntimeOptions()
|
|
3146
3618
|
return await self.describe_domain_resolve_with_options_async(request, runtime)
|
|
3147
3619
|
|
|
3620
|
+
def describe_download_task_with_options(
|
|
3621
|
+
self,
|
|
3622
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskRequest,
|
|
3623
|
+
runtime: util_models.RuntimeOptions,
|
|
3624
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskResponse:
|
|
3625
|
+
UtilClient.validate_model(request)
|
|
3626
|
+
query = {}
|
|
3627
|
+
if not UtilClient.is_unset(request.current_page):
|
|
3628
|
+
query['CurrentPage'] = request.current_page
|
|
3629
|
+
if not UtilClient.is_unset(request.lang):
|
|
3630
|
+
query['Lang'] = request.lang
|
|
3631
|
+
if not UtilClient.is_unset(request.page_size):
|
|
3632
|
+
query['PageSize'] = request.page_size
|
|
3633
|
+
if not UtilClient.is_unset(request.task_type):
|
|
3634
|
+
query['TaskType'] = request.task_type
|
|
3635
|
+
req = open_api_models.OpenApiRequest(
|
|
3636
|
+
query=OpenApiUtilClient.query(query)
|
|
3637
|
+
)
|
|
3638
|
+
params = open_api_models.Params(
|
|
3639
|
+
action='DescribeDownloadTask',
|
|
3640
|
+
version='2017-12-07',
|
|
3641
|
+
protocol='HTTPS',
|
|
3642
|
+
pathname='/',
|
|
3643
|
+
method='POST',
|
|
3644
|
+
auth_type='AK',
|
|
3645
|
+
style='RPC',
|
|
3646
|
+
req_body_type='formData',
|
|
3647
|
+
body_type='json'
|
|
3648
|
+
)
|
|
3649
|
+
return TeaCore.from_map(
|
|
3650
|
+
cloudfw_20171207_models.DescribeDownloadTaskResponse(),
|
|
3651
|
+
self.call_api(params, req, runtime)
|
|
3652
|
+
)
|
|
3653
|
+
|
|
3654
|
+
async def describe_download_task_with_options_async(
|
|
3655
|
+
self,
|
|
3656
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskRequest,
|
|
3657
|
+
runtime: util_models.RuntimeOptions,
|
|
3658
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskResponse:
|
|
3659
|
+
UtilClient.validate_model(request)
|
|
3660
|
+
query = {}
|
|
3661
|
+
if not UtilClient.is_unset(request.current_page):
|
|
3662
|
+
query['CurrentPage'] = request.current_page
|
|
3663
|
+
if not UtilClient.is_unset(request.lang):
|
|
3664
|
+
query['Lang'] = request.lang
|
|
3665
|
+
if not UtilClient.is_unset(request.page_size):
|
|
3666
|
+
query['PageSize'] = request.page_size
|
|
3667
|
+
if not UtilClient.is_unset(request.task_type):
|
|
3668
|
+
query['TaskType'] = request.task_type
|
|
3669
|
+
req = open_api_models.OpenApiRequest(
|
|
3670
|
+
query=OpenApiUtilClient.query(query)
|
|
3671
|
+
)
|
|
3672
|
+
params = open_api_models.Params(
|
|
3673
|
+
action='DescribeDownloadTask',
|
|
3674
|
+
version='2017-12-07',
|
|
3675
|
+
protocol='HTTPS',
|
|
3676
|
+
pathname='/',
|
|
3677
|
+
method='POST',
|
|
3678
|
+
auth_type='AK',
|
|
3679
|
+
style='RPC',
|
|
3680
|
+
req_body_type='formData',
|
|
3681
|
+
body_type='json'
|
|
3682
|
+
)
|
|
3683
|
+
return TeaCore.from_map(
|
|
3684
|
+
cloudfw_20171207_models.DescribeDownloadTaskResponse(),
|
|
3685
|
+
await self.call_api_async(params, req, runtime)
|
|
3686
|
+
)
|
|
3687
|
+
|
|
3688
|
+
def describe_download_task(
|
|
3689
|
+
self,
|
|
3690
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskRequest,
|
|
3691
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskResponse:
|
|
3692
|
+
runtime = util_models.RuntimeOptions()
|
|
3693
|
+
return self.describe_download_task_with_options(request, runtime)
|
|
3694
|
+
|
|
3695
|
+
async def describe_download_task_async(
|
|
3696
|
+
self,
|
|
3697
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskRequest,
|
|
3698
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskResponse:
|
|
3699
|
+
runtime = util_models.RuntimeOptions()
|
|
3700
|
+
return await self.describe_download_task_with_options_async(request, runtime)
|
|
3701
|
+
|
|
3702
|
+
def describe_download_task_type_with_options(
|
|
3703
|
+
self,
|
|
3704
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskTypeRequest,
|
|
3705
|
+
runtime: util_models.RuntimeOptions,
|
|
3706
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskTypeResponse:
|
|
3707
|
+
UtilClient.validate_model(request)
|
|
3708
|
+
query = {}
|
|
3709
|
+
if not UtilClient.is_unset(request.current_page):
|
|
3710
|
+
query['CurrentPage'] = request.current_page
|
|
3711
|
+
if not UtilClient.is_unset(request.lang):
|
|
3712
|
+
query['Lang'] = request.lang
|
|
3713
|
+
if not UtilClient.is_unset(request.page_size):
|
|
3714
|
+
query['PageSize'] = request.page_size
|
|
3715
|
+
if not UtilClient.is_unset(request.task_type):
|
|
3716
|
+
query['TaskType'] = request.task_type
|
|
3717
|
+
req = open_api_models.OpenApiRequest(
|
|
3718
|
+
query=OpenApiUtilClient.query(query)
|
|
3719
|
+
)
|
|
3720
|
+
params = open_api_models.Params(
|
|
3721
|
+
action='DescribeDownloadTaskType',
|
|
3722
|
+
version='2017-12-07',
|
|
3723
|
+
protocol='HTTPS',
|
|
3724
|
+
pathname='/',
|
|
3725
|
+
method='POST',
|
|
3726
|
+
auth_type='AK',
|
|
3727
|
+
style='RPC',
|
|
3728
|
+
req_body_type='formData',
|
|
3729
|
+
body_type='json'
|
|
3730
|
+
)
|
|
3731
|
+
return TeaCore.from_map(
|
|
3732
|
+
cloudfw_20171207_models.DescribeDownloadTaskTypeResponse(),
|
|
3733
|
+
self.call_api(params, req, runtime)
|
|
3734
|
+
)
|
|
3735
|
+
|
|
3736
|
+
async def describe_download_task_type_with_options_async(
|
|
3737
|
+
self,
|
|
3738
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskTypeRequest,
|
|
3739
|
+
runtime: util_models.RuntimeOptions,
|
|
3740
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskTypeResponse:
|
|
3741
|
+
UtilClient.validate_model(request)
|
|
3742
|
+
query = {}
|
|
3743
|
+
if not UtilClient.is_unset(request.current_page):
|
|
3744
|
+
query['CurrentPage'] = request.current_page
|
|
3745
|
+
if not UtilClient.is_unset(request.lang):
|
|
3746
|
+
query['Lang'] = request.lang
|
|
3747
|
+
if not UtilClient.is_unset(request.page_size):
|
|
3748
|
+
query['PageSize'] = request.page_size
|
|
3749
|
+
if not UtilClient.is_unset(request.task_type):
|
|
3750
|
+
query['TaskType'] = request.task_type
|
|
3751
|
+
req = open_api_models.OpenApiRequest(
|
|
3752
|
+
query=OpenApiUtilClient.query(query)
|
|
3753
|
+
)
|
|
3754
|
+
params = open_api_models.Params(
|
|
3755
|
+
action='DescribeDownloadTaskType',
|
|
3756
|
+
version='2017-12-07',
|
|
3757
|
+
protocol='HTTPS',
|
|
3758
|
+
pathname='/',
|
|
3759
|
+
method='POST',
|
|
3760
|
+
auth_type='AK',
|
|
3761
|
+
style='RPC',
|
|
3762
|
+
req_body_type='formData',
|
|
3763
|
+
body_type='json'
|
|
3764
|
+
)
|
|
3765
|
+
return TeaCore.from_map(
|
|
3766
|
+
cloudfw_20171207_models.DescribeDownloadTaskTypeResponse(),
|
|
3767
|
+
await self.call_api_async(params, req, runtime)
|
|
3768
|
+
)
|
|
3769
|
+
|
|
3770
|
+
def describe_download_task_type(
|
|
3771
|
+
self,
|
|
3772
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskTypeRequest,
|
|
3773
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskTypeResponse:
|
|
3774
|
+
runtime = util_models.RuntimeOptions()
|
|
3775
|
+
return self.describe_download_task_type_with_options(request, runtime)
|
|
3776
|
+
|
|
3777
|
+
async def describe_download_task_type_async(
|
|
3778
|
+
self,
|
|
3779
|
+
request: cloudfw_20171207_models.DescribeDownloadTaskTypeRequest,
|
|
3780
|
+
) -> cloudfw_20171207_models.DescribeDownloadTaskTypeResponse:
|
|
3781
|
+
runtime = util_models.RuntimeOptions()
|
|
3782
|
+
return await self.describe_download_task_type_with_options_async(request, runtime)
|
|
3783
|
+
|
|
3148
3784
|
def describe_instance_members_with_options(
|
|
3149
3785
|
self,
|
|
3150
3786
|
request: cloudfw_20171207_models.DescribeInstanceMembersRequest,
|
|
@@ -3265,6 +3901,80 @@ class Client(OpenApiClient):
|
|
|
3265
3901
|
runtime = util_models.RuntimeOptions()
|
|
3266
3902
|
return await self.describe_instance_members_with_options_async(request, runtime)
|
|
3267
3903
|
|
|
3904
|
+
def describe_instance_risk_levels_with_options(
|
|
3905
|
+
self,
|
|
3906
|
+
request: cloudfw_20171207_models.DescribeInstanceRiskLevelsRequest,
|
|
3907
|
+
runtime: util_models.RuntimeOptions,
|
|
3908
|
+
) -> cloudfw_20171207_models.DescribeInstanceRiskLevelsResponse:
|
|
3909
|
+
UtilClient.validate_model(request)
|
|
3910
|
+
query = {}
|
|
3911
|
+
if not UtilClient.is_unset(request.instances):
|
|
3912
|
+
query['Instances'] = request.instances
|
|
3913
|
+
if not UtilClient.is_unset(request.lang):
|
|
3914
|
+
query['Lang'] = request.lang
|
|
3915
|
+
req = open_api_models.OpenApiRequest(
|
|
3916
|
+
query=OpenApiUtilClient.query(query)
|
|
3917
|
+
)
|
|
3918
|
+
params = open_api_models.Params(
|
|
3919
|
+
action='DescribeInstanceRiskLevels',
|
|
3920
|
+
version='2017-12-07',
|
|
3921
|
+
protocol='HTTPS',
|
|
3922
|
+
pathname='/',
|
|
3923
|
+
method='POST',
|
|
3924
|
+
auth_type='AK',
|
|
3925
|
+
style='RPC',
|
|
3926
|
+
req_body_type='formData',
|
|
3927
|
+
body_type='json'
|
|
3928
|
+
)
|
|
3929
|
+
return TeaCore.from_map(
|
|
3930
|
+
cloudfw_20171207_models.DescribeInstanceRiskLevelsResponse(),
|
|
3931
|
+
self.call_api(params, req, runtime)
|
|
3932
|
+
)
|
|
3933
|
+
|
|
3934
|
+
async def describe_instance_risk_levels_with_options_async(
|
|
3935
|
+
self,
|
|
3936
|
+
request: cloudfw_20171207_models.DescribeInstanceRiskLevelsRequest,
|
|
3937
|
+
runtime: util_models.RuntimeOptions,
|
|
3938
|
+
) -> cloudfw_20171207_models.DescribeInstanceRiskLevelsResponse:
|
|
3939
|
+
UtilClient.validate_model(request)
|
|
3940
|
+
query = {}
|
|
3941
|
+
if not UtilClient.is_unset(request.instances):
|
|
3942
|
+
query['Instances'] = request.instances
|
|
3943
|
+
if not UtilClient.is_unset(request.lang):
|
|
3944
|
+
query['Lang'] = request.lang
|
|
3945
|
+
req = open_api_models.OpenApiRequest(
|
|
3946
|
+
query=OpenApiUtilClient.query(query)
|
|
3947
|
+
)
|
|
3948
|
+
params = open_api_models.Params(
|
|
3949
|
+
action='DescribeInstanceRiskLevels',
|
|
3950
|
+
version='2017-12-07',
|
|
3951
|
+
protocol='HTTPS',
|
|
3952
|
+
pathname='/',
|
|
3953
|
+
method='POST',
|
|
3954
|
+
auth_type='AK',
|
|
3955
|
+
style='RPC',
|
|
3956
|
+
req_body_type='formData',
|
|
3957
|
+
body_type='json'
|
|
3958
|
+
)
|
|
3959
|
+
return TeaCore.from_map(
|
|
3960
|
+
cloudfw_20171207_models.DescribeInstanceRiskLevelsResponse(),
|
|
3961
|
+
await self.call_api_async(params, req, runtime)
|
|
3962
|
+
)
|
|
3963
|
+
|
|
3964
|
+
def describe_instance_risk_levels(
|
|
3965
|
+
self,
|
|
3966
|
+
request: cloudfw_20171207_models.DescribeInstanceRiskLevelsRequest,
|
|
3967
|
+
) -> cloudfw_20171207_models.DescribeInstanceRiskLevelsResponse:
|
|
3968
|
+
runtime = util_models.RuntimeOptions()
|
|
3969
|
+
return self.describe_instance_risk_levels_with_options(request, runtime)
|
|
3970
|
+
|
|
3971
|
+
async def describe_instance_risk_levels_async(
|
|
3972
|
+
self,
|
|
3973
|
+
request: cloudfw_20171207_models.DescribeInstanceRiskLevelsRequest,
|
|
3974
|
+
) -> cloudfw_20171207_models.DescribeInstanceRiskLevelsResponse:
|
|
3975
|
+
runtime = util_models.RuntimeOptions()
|
|
3976
|
+
return await self.describe_instance_risk_levels_with_options_async(request, runtime)
|
|
3977
|
+
|
|
3268
3978
|
def describe_internet_open_ip_with_options(
|
|
3269
3979
|
self,
|
|
3270
3980
|
request: cloudfw_20171207_models.DescribeInternetOpenIpRequest,
|
|
@@ -3619,6 +4329,76 @@ class Client(OpenApiClient):
|
|
|
3619
4329
|
runtime = util_models.RuntimeOptions()
|
|
3620
4330
|
return await self.describe_invade_event_list_with_options_async(request, runtime)
|
|
3621
4331
|
|
|
4332
|
+
def describe_nat_acl_page_status_with_options(
|
|
4333
|
+
self,
|
|
4334
|
+
request: cloudfw_20171207_models.DescribeNatAclPageStatusRequest,
|
|
4335
|
+
runtime: util_models.RuntimeOptions,
|
|
4336
|
+
) -> cloudfw_20171207_models.DescribeNatAclPageStatusResponse:
|
|
4337
|
+
UtilClient.validate_model(request)
|
|
4338
|
+
query = {}
|
|
4339
|
+
if not UtilClient.is_unset(request.lang):
|
|
4340
|
+
query['Lang'] = request.lang
|
|
4341
|
+
req = open_api_models.OpenApiRequest(
|
|
4342
|
+
query=OpenApiUtilClient.query(query)
|
|
4343
|
+
)
|
|
4344
|
+
params = open_api_models.Params(
|
|
4345
|
+
action='DescribeNatAclPageStatus',
|
|
4346
|
+
version='2017-12-07',
|
|
4347
|
+
protocol='HTTPS',
|
|
4348
|
+
pathname='/',
|
|
4349
|
+
method='POST',
|
|
4350
|
+
auth_type='AK',
|
|
4351
|
+
style='RPC',
|
|
4352
|
+
req_body_type='formData',
|
|
4353
|
+
body_type='json'
|
|
4354
|
+
)
|
|
4355
|
+
return TeaCore.from_map(
|
|
4356
|
+
cloudfw_20171207_models.DescribeNatAclPageStatusResponse(),
|
|
4357
|
+
self.call_api(params, req, runtime)
|
|
4358
|
+
)
|
|
4359
|
+
|
|
4360
|
+
async def describe_nat_acl_page_status_with_options_async(
|
|
4361
|
+
self,
|
|
4362
|
+
request: cloudfw_20171207_models.DescribeNatAclPageStatusRequest,
|
|
4363
|
+
runtime: util_models.RuntimeOptions,
|
|
4364
|
+
) -> cloudfw_20171207_models.DescribeNatAclPageStatusResponse:
|
|
4365
|
+
UtilClient.validate_model(request)
|
|
4366
|
+
query = {}
|
|
4367
|
+
if not UtilClient.is_unset(request.lang):
|
|
4368
|
+
query['Lang'] = request.lang
|
|
4369
|
+
req = open_api_models.OpenApiRequest(
|
|
4370
|
+
query=OpenApiUtilClient.query(query)
|
|
4371
|
+
)
|
|
4372
|
+
params = open_api_models.Params(
|
|
4373
|
+
action='DescribeNatAclPageStatus',
|
|
4374
|
+
version='2017-12-07',
|
|
4375
|
+
protocol='HTTPS',
|
|
4376
|
+
pathname='/',
|
|
4377
|
+
method='POST',
|
|
4378
|
+
auth_type='AK',
|
|
4379
|
+
style='RPC',
|
|
4380
|
+
req_body_type='formData',
|
|
4381
|
+
body_type='json'
|
|
4382
|
+
)
|
|
4383
|
+
return TeaCore.from_map(
|
|
4384
|
+
cloudfw_20171207_models.DescribeNatAclPageStatusResponse(),
|
|
4385
|
+
await self.call_api_async(params, req, runtime)
|
|
4386
|
+
)
|
|
4387
|
+
|
|
4388
|
+
def describe_nat_acl_page_status(
|
|
4389
|
+
self,
|
|
4390
|
+
request: cloudfw_20171207_models.DescribeNatAclPageStatusRequest,
|
|
4391
|
+
) -> cloudfw_20171207_models.DescribeNatAclPageStatusResponse:
|
|
4392
|
+
runtime = util_models.RuntimeOptions()
|
|
4393
|
+
return self.describe_nat_acl_page_status_with_options(request, runtime)
|
|
4394
|
+
|
|
4395
|
+
async def describe_nat_acl_page_status_async(
|
|
4396
|
+
self,
|
|
4397
|
+
request: cloudfw_20171207_models.DescribeNatAclPageStatusRequest,
|
|
4398
|
+
) -> cloudfw_20171207_models.DescribeNatAclPageStatusResponse:
|
|
4399
|
+
runtime = util_models.RuntimeOptions()
|
|
4400
|
+
return await self.describe_nat_acl_page_status_with_options_async(request, runtime)
|
|
4401
|
+
|
|
3622
4402
|
def describe_nat_firewall_control_policy_with_options(
|
|
3623
4403
|
self,
|
|
3624
4404
|
request: cloudfw_20171207_models.DescribeNatFirewallControlPolicyRequest,
|
|
@@ -4331,73 +5111,34 @@ class Client(OpenApiClient):
|
|
|
4331
5111
|
runtime = util_models.RuntimeOptions()
|
|
4332
5112
|
return await self.describe_policy_prior_used_with_options_async(request, runtime)
|
|
4333
5113
|
|
|
4334
|
-
def
|
|
5114
|
+
def describe_postpay_traffic_detail_with_options(
|
|
4335
5115
|
self,
|
|
4336
|
-
request: cloudfw_20171207_models.
|
|
5116
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficDetailRequest,
|
|
4337
5117
|
runtime: util_models.RuntimeOptions,
|
|
4338
|
-
) -> cloudfw_20171207_models.
|
|
4339
|
-
"""
|
|
4340
|
-
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
4341
|
-
## Limits
|
|
4342
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
4343
|
-
|
|
4344
|
-
@param request: DescribeRiskEventGroupRequest
|
|
4345
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
4346
|
-
@return: DescribeRiskEventGroupResponse
|
|
4347
|
-
"""
|
|
5118
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficDetailResponse:
|
|
4348
5119
|
UtilClient.validate_model(request)
|
|
4349
5120
|
query = {}
|
|
4350
|
-
if not UtilClient.is_unset(request.attack_app):
|
|
4351
|
-
query['AttackApp'] = request.attack_app
|
|
4352
|
-
if not UtilClient.is_unset(request.attack_type):
|
|
4353
|
-
query['AttackType'] = request.attack_type
|
|
4354
|
-
if not UtilClient.is_unset(request.buy_version):
|
|
4355
|
-
query['BuyVersion'] = request.buy_version
|
|
4356
5121
|
if not UtilClient.is_unset(request.current_page):
|
|
4357
5122
|
query['CurrentPage'] = request.current_page
|
|
4358
|
-
if not UtilClient.is_unset(request.data_type):
|
|
4359
|
-
query['DataType'] = request.data_type
|
|
4360
|
-
if not UtilClient.is_unset(request.direction):
|
|
4361
|
-
query['Direction'] = request.direction
|
|
4362
|
-
if not UtilClient.is_unset(request.dst_ip):
|
|
4363
|
-
query['DstIP'] = request.dst_ip
|
|
4364
|
-
if not UtilClient.is_unset(request.dst_network_instance_id):
|
|
4365
|
-
query['DstNetworkInstanceId'] = request.dst_network_instance_id
|
|
4366
5123
|
if not UtilClient.is_unset(request.end_time):
|
|
4367
5124
|
query['EndTime'] = request.end_time
|
|
4368
|
-
if not UtilClient.is_unset(request.event_name):
|
|
4369
|
-
query['EventName'] = request.event_name
|
|
4370
|
-
if not UtilClient.is_unset(request.firewall_type):
|
|
4371
|
-
query['FirewallType'] = request.firewall_type
|
|
4372
|
-
if not UtilClient.is_unset(request.lang):
|
|
4373
|
-
query['Lang'] = request.lang
|
|
4374
5125
|
if not UtilClient.is_unset(request.lang):
|
|
4375
5126
|
query['Lang'] = request.lang
|
|
4376
|
-
if not UtilClient.is_unset(request.no_location):
|
|
4377
|
-
query['NoLocation'] = request.no_location
|
|
4378
5127
|
if not UtilClient.is_unset(request.order):
|
|
4379
5128
|
query['Order'] = request.order
|
|
4380
5129
|
if not UtilClient.is_unset(request.page_size):
|
|
4381
5130
|
query['PageSize'] = request.page_size
|
|
4382
|
-
if not UtilClient.is_unset(request.
|
|
4383
|
-
query['
|
|
4384
|
-
if not UtilClient.is_unset(request.rule_source):
|
|
4385
|
-
query['RuleSource'] = request.rule_source
|
|
4386
|
-
if not UtilClient.is_unset(request.sort):
|
|
4387
|
-
query['Sort'] = request.sort
|
|
4388
|
-
if not UtilClient.is_unset(request.src_ip):
|
|
4389
|
-
query['SrcIP'] = request.src_ip
|
|
4390
|
-
if not UtilClient.is_unset(request.src_network_instance_id):
|
|
4391
|
-
query['SrcNetworkInstanceId'] = request.src_network_instance_id
|
|
5131
|
+
if not UtilClient.is_unset(request.search_item):
|
|
5132
|
+
query['SearchItem'] = request.search_item
|
|
4392
5133
|
if not UtilClient.is_unset(request.start_time):
|
|
4393
5134
|
query['StartTime'] = request.start_time
|
|
4394
|
-
if not UtilClient.is_unset(request.
|
|
4395
|
-
query['
|
|
5135
|
+
if not UtilClient.is_unset(request.traffic_type):
|
|
5136
|
+
query['TrafficType'] = request.traffic_type
|
|
4396
5137
|
req = open_api_models.OpenApiRequest(
|
|
4397
5138
|
query=OpenApiUtilClient.query(query)
|
|
4398
5139
|
)
|
|
4399
5140
|
params = open_api_models.Params(
|
|
4400
|
-
action='
|
|
5141
|
+
action='DescribePostpayTrafficDetail',
|
|
4401
5142
|
version='2017-12-07',
|
|
4402
5143
|
protocol='HTTPS',
|
|
4403
5144
|
pathname='/',
|
|
@@ -4408,77 +5149,38 @@ class Client(OpenApiClient):
|
|
|
4408
5149
|
body_type='json'
|
|
4409
5150
|
)
|
|
4410
5151
|
return TeaCore.from_map(
|
|
4411
|
-
cloudfw_20171207_models.
|
|
5152
|
+
cloudfw_20171207_models.DescribePostpayTrafficDetailResponse(),
|
|
4412
5153
|
self.call_api(params, req, runtime)
|
|
4413
5154
|
)
|
|
4414
5155
|
|
|
4415
|
-
async def
|
|
5156
|
+
async def describe_postpay_traffic_detail_with_options_async(
|
|
4416
5157
|
self,
|
|
4417
|
-
request: cloudfw_20171207_models.
|
|
5158
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficDetailRequest,
|
|
4418
5159
|
runtime: util_models.RuntimeOptions,
|
|
4419
|
-
) -> cloudfw_20171207_models.
|
|
4420
|
-
"""
|
|
4421
|
-
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
4422
|
-
## Limits
|
|
4423
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
4424
|
-
|
|
4425
|
-
@param request: DescribeRiskEventGroupRequest
|
|
4426
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
4427
|
-
@return: DescribeRiskEventGroupResponse
|
|
4428
|
-
"""
|
|
5160
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficDetailResponse:
|
|
4429
5161
|
UtilClient.validate_model(request)
|
|
4430
5162
|
query = {}
|
|
4431
|
-
if not UtilClient.is_unset(request.attack_app):
|
|
4432
|
-
query['AttackApp'] = request.attack_app
|
|
4433
|
-
if not UtilClient.is_unset(request.attack_type):
|
|
4434
|
-
query['AttackType'] = request.attack_type
|
|
4435
|
-
if not UtilClient.is_unset(request.buy_version):
|
|
4436
|
-
query['BuyVersion'] = request.buy_version
|
|
4437
5163
|
if not UtilClient.is_unset(request.current_page):
|
|
4438
5164
|
query['CurrentPage'] = request.current_page
|
|
4439
|
-
if not UtilClient.is_unset(request.data_type):
|
|
4440
|
-
query['DataType'] = request.data_type
|
|
4441
|
-
if not UtilClient.is_unset(request.direction):
|
|
4442
|
-
query['Direction'] = request.direction
|
|
4443
|
-
if not UtilClient.is_unset(request.dst_ip):
|
|
4444
|
-
query['DstIP'] = request.dst_ip
|
|
4445
|
-
if not UtilClient.is_unset(request.dst_network_instance_id):
|
|
4446
|
-
query['DstNetworkInstanceId'] = request.dst_network_instance_id
|
|
4447
5165
|
if not UtilClient.is_unset(request.end_time):
|
|
4448
5166
|
query['EndTime'] = request.end_time
|
|
4449
|
-
if not UtilClient.is_unset(request.event_name):
|
|
4450
|
-
query['EventName'] = request.event_name
|
|
4451
|
-
if not UtilClient.is_unset(request.firewall_type):
|
|
4452
|
-
query['FirewallType'] = request.firewall_type
|
|
4453
|
-
if not UtilClient.is_unset(request.lang):
|
|
4454
|
-
query['Lang'] = request.lang
|
|
4455
5167
|
if not UtilClient.is_unset(request.lang):
|
|
4456
5168
|
query['Lang'] = request.lang
|
|
4457
|
-
if not UtilClient.is_unset(request.no_location):
|
|
4458
|
-
query['NoLocation'] = request.no_location
|
|
4459
5169
|
if not UtilClient.is_unset(request.order):
|
|
4460
5170
|
query['Order'] = request.order
|
|
4461
5171
|
if not UtilClient.is_unset(request.page_size):
|
|
4462
5172
|
query['PageSize'] = request.page_size
|
|
4463
|
-
if not UtilClient.is_unset(request.
|
|
4464
|
-
query['
|
|
4465
|
-
if not UtilClient.is_unset(request.rule_source):
|
|
4466
|
-
query['RuleSource'] = request.rule_source
|
|
4467
|
-
if not UtilClient.is_unset(request.sort):
|
|
4468
|
-
query['Sort'] = request.sort
|
|
4469
|
-
if not UtilClient.is_unset(request.src_ip):
|
|
4470
|
-
query['SrcIP'] = request.src_ip
|
|
4471
|
-
if not UtilClient.is_unset(request.src_network_instance_id):
|
|
4472
|
-
query['SrcNetworkInstanceId'] = request.src_network_instance_id
|
|
5173
|
+
if not UtilClient.is_unset(request.search_item):
|
|
5174
|
+
query['SearchItem'] = request.search_item
|
|
4473
5175
|
if not UtilClient.is_unset(request.start_time):
|
|
4474
5176
|
query['StartTime'] = request.start_time
|
|
4475
|
-
if not UtilClient.is_unset(request.
|
|
4476
|
-
query['
|
|
5177
|
+
if not UtilClient.is_unset(request.traffic_type):
|
|
5178
|
+
query['TrafficType'] = request.traffic_type
|
|
4477
5179
|
req = open_api_models.OpenApiRequest(
|
|
4478
5180
|
query=OpenApiUtilClient.query(query)
|
|
4479
5181
|
)
|
|
4480
5182
|
params = open_api_models.Params(
|
|
4481
|
-
action='
|
|
5183
|
+
action='DescribePostpayTrafficDetail',
|
|
4482
5184
|
version='2017-12-07',
|
|
4483
5185
|
protocol='HTTPS',
|
|
4484
5186
|
pathname='/',
|
|
@@ -4489,70 +5191,382 @@ class Client(OpenApiClient):
|
|
|
4489
5191
|
body_type='json'
|
|
4490
5192
|
)
|
|
4491
5193
|
return TeaCore.from_map(
|
|
4492
|
-
cloudfw_20171207_models.
|
|
5194
|
+
cloudfw_20171207_models.DescribePostpayTrafficDetailResponse(),
|
|
4493
5195
|
await self.call_api_async(params, req, runtime)
|
|
4494
5196
|
)
|
|
4495
5197
|
|
|
4496
|
-
def
|
|
5198
|
+
def describe_postpay_traffic_detail(
|
|
4497
5199
|
self,
|
|
4498
|
-
request: cloudfw_20171207_models.
|
|
4499
|
-
) -> cloudfw_20171207_models.
|
|
4500
|
-
"""
|
|
4501
|
-
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
4502
|
-
## Limits
|
|
4503
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
4504
|
-
|
|
4505
|
-
@param request: DescribeRiskEventGroupRequest
|
|
4506
|
-
@return: DescribeRiskEventGroupResponse
|
|
4507
|
-
"""
|
|
5200
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficDetailRequest,
|
|
5201
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficDetailResponse:
|
|
4508
5202
|
runtime = util_models.RuntimeOptions()
|
|
4509
|
-
return self.
|
|
5203
|
+
return self.describe_postpay_traffic_detail_with_options(request, runtime)
|
|
4510
5204
|
|
|
4511
|
-
async def
|
|
5205
|
+
async def describe_postpay_traffic_detail_async(
|
|
4512
5206
|
self,
|
|
4513
|
-
request: cloudfw_20171207_models.
|
|
4514
|
-
) -> cloudfw_20171207_models.
|
|
4515
|
-
"""
|
|
4516
|
-
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
4517
|
-
## Limits
|
|
4518
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
4519
|
-
|
|
4520
|
-
@param request: DescribeRiskEventGroupRequest
|
|
4521
|
-
@return: DescribeRiskEventGroupResponse
|
|
4522
|
-
"""
|
|
5207
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficDetailRequest,
|
|
5208
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficDetailResponse:
|
|
4523
5209
|
runtime = util_models.RuntimeOptions()
|
|
4524
|
-
return await self.
|
|
5210
|
+
return await self.describe_postpay_traffic_detail_with_options_async(request, runtime)
|
|
4525
5211
|
|
|
4526
|
-
def
|
|
5212
|
+
def describe_postpay_traffic_total_with_options(
|
|
4527
5213
|
self,
|
|
4528
|
-
request: cloudfw_20171207_models.
|
|
5214
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficTotalRequest,
|
|
4529
5215
|
runtime: util_models.RuntimeOptions,
|
|
4530
|
-
) -> cloudfw_20171207_models.
|
|
5216
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficTotalResponse:
|
|
4531
5217
|
UtilClient.validate_model(request)
|
|
4532
5218
|
query = {}
|
|
4533
|
-
if not UtilClient.is_unset(request.
|
|
4534
|
-
query['
|
|
4535
|
-
if not UtilClient.is_unset(request.dst_vpc_id):
|
|
4536
|
-
query['DstVpcId'] = request.dst_vpc_id
|
|
4537
|
-
if not UtilClient.is_unset(request.end_time):
|
|
4538
|
-
query['EndTime'] = request.end_time
|
|
4539
|
-
if not UtilClient.is_unset(request.firewall_type):
|
|
4540
|
-
query['FirewallType'] = request.firewall_type
|
|
4541
|
-
if not UtilClient.is_unset(request.public_ip):
|
|
4542
|
-
query['PublicIP'] = request.public_ip
|
|
4543
|
-
if not UtilClient.is_unset(request.src_ip):
|
|
4544
|
-
query['SrcIP'] = request.src_ip
|
|
4545
|
-
if not UtilClient.is_unset(request.src_vpc_id):
|
|
4546
|
-
query['SrcVpcId'] = request.src_vpc_id
|
|
4547
|
-
if not UtilClient.is_unset(request.start_time):
|
|
4548
|
-
query['StartTime'] = request.start_time
|
|
4549
|
-
if not UtilClient.is_unset(request.uuid):
|
|
4550
|
-
query['UUID'] = request.uuid
|
|
5219
|
+
if not UtilClient.is_unset(request.lang):
|
|
5220
|
+
query['Lang'] = request.lang
|
|
4551
5221
|
req = open_api_models.OpenApiRequest(
|
|
4552
5222
|
query=OpenApiUtilClient.query(query)
|
|
4553
5223
|
)
|
|
4554
5224
|
params = open_api_models.Params(
|
|
4555
|
-
action='
|
|
5225
|
+
action='DescribePostpayTrafficTotal',
|
|
5226
|
+
version='2017-12-07',
|
|
5227
|
+
protocol='HTTPS',
|
|
5228
|
+
pathname='/',
|
|
5229
|
+
method='POST',
|
|
5230
|
+
auth_type='AK',
|
|
5231
|
+
style='RPC',
|
|
5232
|
+
req_body_type='formData',
|
|
5233
|
+
body_type='json'
|
|
5234
|
+
)
|
|
5235
|
+
return TeaCore.from_map(
|
|
5236
|
+
cloudfw_20171207_models.DescribePostpayTrafficTotalResponse(),
|
|
5237
|
+
self.call_api(params, req, runtime)
|
|
5238
|
+
)
|
|
5239
|
+
|
|
5240
|
+
async def describe_postpay_traffic_total_with_options_async(
|
|
5241
|
+
self,
|
|
5242
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficTotalRequest,
|
|
5243
|
+
runtime: util_models.RuntimeOptions,
|
|
5244
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficTotalResponse:
|
|
5245
|
+
UtilClient.validate_model(request)
|
|
5246
|
+
query = {}
|
|
5247
|
+
if not UtilClient.is_unset(request.lang):
|
|
5248
|
+
query['Lang'] = request.lang
|
|
5249
|
+
req = open_api_models.OpenApiRequest(
|
|
5250
|
+
query=OpenApiUtilClient.query(query)
|
|
5251
|
+
)
|
|
5252
|
+
params = open_api_models.Params(
|
|
5253
|
+
action='DescribePostpayTrafficTotal',
|
|
5254
|
+
version='2017-12-07',
|
|
5255
|
+
protocol='HTTPS',
|
|
5256
|
+
pathname='/',
|
|
5257
|
+
method='POST',
|
|
5258
|
+
auth_type='AK',
|
|
5259
|
+
style='RPC',
|
|
5260
|
+
req_body_type='formData',
|
|
5261
|
+
body_type='json'
|
|
5262
|
+
)
|
|
5263
|
+
return TeaCore.from_map(
|
|
5264
|
+
cloudfw_20171207_models.DescribePostpayTrafficTotalResponse(),
|
|
5265
|
+
await self.call_api_async(params, req, runtime)
|
|
5266
|
+
)
|
|
5267
|
+
|
|
5268
|
+
def describe_postpay_traffic_total(
|
|
5269
|
+
self,
|
|
5270
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficTotalRequest,
|
|
5271
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficTotalResponse:
|
|
5272
|
+
runtime = util_models.RuntimeOptions()
|
|
5273
|
+
return self.describe_postpay_traffic_total_with_options(request, runtime)
|
|
5274
|
+
|
|
5275
|
+
async def describe_postpay_traffic_total_async(
|
|
5276
|
+
self,
|
|
5277
|
+
request: cloudfw_20171207_models.DescribePostpayTrafficTotalRequest,
|
|
5278
|
+
) -> cloudfw_20171207_models.DescribePostpayTrafficTotalResponse:
|
|
5279
|
+
runtime = util_models.RuntimeOptions()
|
|
5280
|
+
return await self.describe_postpay_traffic_total_with_options_async(request, runtime)
|
|
5281
|
+
|
|
5282
|
+
def describe_prefix_lists_with_options(
|
|
5283
|
+
self,
|
|
5284
|
+
request: cloudfw_20171207_models.DescribePrefixListsRequest,
|
|
5285
|
+
runtime: util_models.RuntimeOptions,
|
|
5286
|
+
) -> cloudfw_20171207_models.DescribePrefixListsResponse:
|
|
5287
|
+
UtilClient.validate_model(request)
|
|
5288
|
+
query = OpenApiUtilClient.query(UtilClient.to_map(request))
|
|
5289
|
+
req = open_api_models.OpenApiRequest(
|
|
5290
|
+
query=OpenApiUtilClient.query(query)
|
|
5291
|
+
)
|
|
5292
|
+
params = open_api_models.Params(
|
|
5293
|
+
action='DescribePrefixLists',
|
|
5294
|
+
version='2017-12-07',
|
|
5295
|
+
protocol='HTTPS',
|
|
5296
|
+
pathname='/',
|
|
5297
|
+
method='GET',
|
|
5298
|
+
auth_type='AK',
|
|
5299
|
+
style='RPC',
|
|
5300
|
+
req_body_type='formData',
|
|
5301
|
+
body_type='json'
|
|
5302
|
+
)
|
|
5303
|
+
return TeaCore.from_map(
|
|
5304
|
+
cloudfw_20171207_models.DescribePrefixListsResponse(),
|
|
5305
|
+
self.call_api(params, req, runtime)
|
|
5306
|
+
)
|
|
5307
|
+
|
|
5308
|
+
async def describe_prefix_lists_with_options_async(
|
|
5309
|
+
self,
|
|
5310
|
+
request: cloudfw_20171207_models.DescribePrefixListsRequest,
|
|
5311
|
+
runtime: util_models.RuntimeOptions,
|
|
5312
|
+
) -> cloudfw_20171207_models.DescribePrefixListsResponse:
|
|
5313
|
+
UtilClient.validate_model(request)
|
|
5314
|
+
query = OpenApiUtilClient.query(UtilClient.to_map(request))
|
|
5315
|
+
req = open_api_models.OpenApiRequest(
|
|
5316
|
+
query=OpenApiUtilClient.query(query)
|
|
5317
|
+
)
|
|
5318
|
+
params = open_api_models.Params(
|
|
5319
|
+
action='DescribePrefixLists',
|
|
5320
|
+
version='2017-12-07',
|
|
5321
|
+
protocol='HTTPS',
|
|
5322
|
+
pathname='/',
|
|
5323
|
+
method='GET',
|
|
5324
|
+
auth_type='AK',
|
|
5325
|
+
style='RPC',
|
|
5326
|
+
req_body_type='formData',
|
|
5327
|
+
body_type='json'
|
|
5328
|
+
)
|
|
5329
|
+
return TeaCore.from_map(
|
|
5330
|
+
cloudfw_20171207_models.DescribePrefixListsResponse(),
|
|
5331
|
+
await self.call_api_async(params, req, runtime)
|
|
5332
|
+
)
|
|
5333
|
+
|
|
5334
|
+
def describe_prefix_lists(
|
|
5335
|
+
self,
|
|
5336
|
+
request: cloudfw_20171207_models.DescribePrefixListsRequest,
|
|
5337
|
+
) -> cloudfw_20171207_models.DescribePrefixListsResponse:
|
|
5338
|
+
runtime = util_models.RuntimeOptions()
|
|
5339
|
+
return self.describe_prefix_lists_with_options(request, runtime)
|
|
5340
|
+
|
|
5341
|
+
async def describe_prefix_lists_async(
|
|
5342
|
+
self,
|
|
5343
|
+
request: cloudfw_20171207_models.DescribePrefixListsRequest,
|
|
5344
|
+
) -> cloudfw_20171207_models.DescribePrefixListsResponse:
|
|
5345
|
+
runtime = util_models.RuntimeOptions()
|
|
5346
|
+
return await self.describe_prefix_lists_with_options_async(request, runtime)
|
|
5347
|
+
|
|
5348
|
+
def describe_risk_event_group_with_options(
|
|
5349
|
+
self,
|
|
5350
|
+
request: cloudfw_20171207_models.DescribeRiskEventGroupRequest,
|
|
5351
|
+
runtime: util_models.RuntimeOptions,
|
|
5352
|
+
) -> cloudfw_20171207_models.DescribeRiskEventGroupResponse:
|
|
5353
|
+
"""
|
|
5354
|
+
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
5355
|
+
## Limits
|
|
5356
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5357
|
+
|
|
5358
|
+
@param request: DescribeRiskEventGroupRequest
|
|
5359
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5360
|
+
@return: DescribeRiskEventGroupResponse
|
|
5361
|
+
"""
|
|
5362
|
+
UtilClient.validate_model(request)
|
|
5363
|
+
query = {}
|
|
5364
|
+
if not UtilClient.is_unset(request.attack_app):
|
|
5365
|
+
query['AttackApp'] = request.attack_app
|
|
5366
|
+
if not UtilClient.is_unset(request.attack_type):
|
|
5367
|
+
query['AttackType'] = request.attack_type
|
|
5368
|
+
if not UtilClient.is_unset(request.buy_version):
|
|
5369
|
+
query['BuyVersion'] = request.buy_version
|
|
5370
|
+
if not UtilClient.is_unset(request.current_page):
|
|
5371
|
+
query['CurrentPage'] = request.current_page
|
|
5372
|
+
if not UtilClient.is_unset(request.data_type):
|
|
5373
|
+
query['DataType'] = request.data_type
|
|
5374
|
+
if not UtilClient.is_unset(request.direction):
|
|
5375
|
+
query['Direction'] = request.direction
|
|
5376
|
+
if not UtilClient.is_unset(request.dst_ip):
|
|
5377
|
+
query['DstIP'] = request.dst_ip
|
|
5378
|
+
if not UtilClient.is_unset(request.dst_network_instance_id):
|
|
5379
|
+
query['DstNetworkInstanceId'] = request.dst_network_instance_id
|
|
5380
|
+
if not UtilClient.is_unset(request.end_time):
|
|
5381
|
+
query['EndTime'] = request.end_time
|
|
5382
|
+
if not UtilClient.is_unset(request.event_name):
|
|
5383
|
+
query['EventName'] = request.event_name
|
|
5384
|
+
if not UtilClient.is_unset(request.firewall_type):
|
|
5385
|
+
query['FirewallType'] = request.firewall_type
|
|
5386
|
+
if not UtilClient.is_unset(request.lang):
|
|
5387
|
+
query['Lang'] = request.lang
|
|
5388
|
+
if not UtilClient.is_unset(request.lang):
|
|
5389
|
+
query['Lang'] = request.lang
|
|
5390
|
+
if not UtilClient.is_unset(request.no_location):
|
|
5391
|
+
query['NoLocation'] = request.no_location
|
|
5392
|
+
if not UtilClient.is_unset(request.order):
|
|
5393
|
+
query['Order'] = request.order
|
|
5394
|
+
if not UtilClient.is_unset(request.page_size):
|
|
5395
|
+
query['PageSize'] = request.page_size
|
|
5396
|
+
if not UtilClient.is_unset(request.rule_result):
|
|
5397
|
+
query['RuleResult'] = request.rule_result
|
|
5398
|
+
if not UtilClient.is_unset(request.rule_source):
|
|
5399
|
+
query['RuleSource'] = request.rule_source
|
|
5400
|
+
if not UtilClient.is_unset(request.sort):
|
|
5401
|
+
query['Sort'] = request.sort
|
|
5402
|
+
if not UtilClient.is_unset(request.src_ip):
|
|
5403
|
+
query['SrcIP'] = request.src_ip
|
|
5404
|
+
if not UtilClient.is_unset(request.src_network_instance_id):
|
|
5405
|
+
query['SrcNetworkInstanceId'] = request.src_network_instance_id
|
|
5406
|
+
if not UtilClient.is_unset(request.start_time):
|
|
5407
|
+
query['StartTime'] = request.start_time
|
|
5408
|
+
if not UtilClient.is_unset(request.vul_level):
|
|
5409
|
+
query['VulLevel'] = request.vul_level
|
|
5410
|
+
req = open_api_models.OpenApiRequest(
|
|
5411
|
+
query=OpenApiUtilClient.query(query)
|
|
5412
|
+
)
|
|
5413
|
+
params = open_api_models.Params(
|
|
5414
|
+
action='DescribeRiskEventGroup',
|
|
5415
|
+
version='2017-12-07',
|
|
5416
|
+
protocol='HTTPS',
|
|
5417
|
+
pathname='/',
|
|
5418
|
+
method='POST',
|
|
5419
|
+
auth_type='AK',
|
|
5420
|
+
style='RPC',
|
|
5421
|
+
req_body_type='formData',
|
|
5422
|
+
body_type='json'
|
|
5423
|
+
)
|
|
5424
|
+
return TeaCore.from_map(
|
|
5425
|
+
cloudfw_20171207_models.DescribeRiskEventGroupResponse(),
|
|
5426
|
+
self.call_api(params, req, runtime)
|
|
5427
|
+
)
|
|
5428
|
+
|
|
5429
|
+
async def describe_risk_event_group_with_options_async(
|
|
5430
|
+
self,
|
|
5431
|
+
request: cloudfw_20171207_models.DescribeRiskEventGroupRequest,
|
|
5432
|
+
runtime: util_models.RuntimeOptions,
|
|
5433
|
+
) -> cloudfw_20171207_models.DescribeRiskEventGroupResponse:
|
|
5434
|
+
"""
|
|
5435
|
+
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
5436
|
+
## Limits
|
|
5437
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5438
|
+
|
|
5439
|
+
@param request: DescribeRiskEventGroupRequest
|
|
5440
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
5441
|
+
@return: DescribeRiskEventGroupResponse
|
|
5442
|
+
"""
|
|
5443
|
+
UtilClient.validate_model(request)
|
|
5444
|
+
query = {}
|
|
5445
|
+
if not UtilClient.is_unset(request.attack_app):
|
|
5446
|
+
query['AttackApp'] = request.attack_app
|
|
5447
|
+
if not UtilClient.is_unset(request.attack_type):
|
|
5448
|
+
query['AttackType'] = request.attack_type
|
|
5449
|
+
if not UtilClient.is_unset(request.buy_version):
|
|
5450
|
+
query['BuyVersion'] = request.buy_version
|
|
5451
|
+
if not UtilClient.is_unset(request.current_page):
|
|
5452
|
+
query['CurrentPage'] = request.current_page
|
|
5453
|
+
if not UtilClient.is_unset(request.data_type):
|
|
5454
|
+
query['DataType'] = request.data_type
|
|
5455
|
+
if not UtilClient.is_unset(request.direction):
|
|
5456
|
+
query['Direction'] = request.direction
|
|
5457
|
+
if not UtilClient.is_unset(request.dst_ip):
|
|
5458
|
+
query['DstIP'] = request.dst_ip
|
|
5459
|
+
if not UtilClient.is_unset(request.dst_network_instance_id):
|
|
5460
|
+
query['DstNetworkInstanceId'] = request.dst_network_instance_id
|
|
5461
|
+
if not UtilClient.is_unset(request.end_time):
|
|
5462
|
+
query['EndTime'] = request.end_time
|
|
5463
|
+
if not UtilClient.is_unset(request.event_name):
|
|
5464
|
+
query['EventName'] = request.event_name
|
|
5465
|
+
if not UtilClient.is_unset(request.firewall_type):
|
|
5466
|
+
query['FirewallType'] = request.firewall_type
|
|
5467
|
+
if not UtilClient.is_unset(request.lang):
|
|
5468
|
+
query['Lang'] = request.lang
|
|
5469
|
+
if not UtilClient.is_unset(request.lang):
|
|
5470
|
+
query['Lang'] = request.lang
|
|
5471
|
+
if not UtilClient.is_unset(request.no_location):
|
|
5472
|
+
query['NoLocation'] = request.no_location
|
|
5473
|
+
if not UtilClient.is_unset(request.order):
|
|
5474
|
+
query['Order'] = request.order
|
|
5475
|
+
if not UtilClient.is_unset(request.page_size):
|
|
5476
|
+
query['PageSize'] = request.page_size
|
|
5477
|
+
if not UtilClient.is_unset(request.rule_result):
|
|
5478
|
+
query['RuleResult'] = request.rule_result
|
|
5479
|
+
if not UtilClient.is_unset(request.rule_source):
|
|
5480
|
+
query['RuleSource'] = request.rule_source
|
|
5481
|
+
if not UtilClient.is_unset(request.sort):
|
|
5482
|
+
query['Sort'] = request.sort
|
|
5483
|
+
if not UtilClient.is_unset(request.src_ip):
|
|
5484
|
+
query['SrcIP'] = request.src_ip
|
|
5485
|
+
if not UtilClient.is_unset(request.src_network_instance_id):
|
|
5486
|
+
query['SrcNetworkInstanceId'] = request.src_network_instance_id
|
|
5487
|
+
if not UtilClient.is_unset(request.start_time):
|
|
5488
|
+
query['StartTime'] = request.start_time
|
|
5489
|
+
if not UtilClient.is_unset(request.vul_level):
|
|
5490
|
+
query['VulLevel'] = request.vul_level
|
|
5491
|
+
req = open_api_models.OpenApiRequest(
|
|
5492
|
+
query=OpenApiUtilClient.query(query)
|
|
5493
|
+
)
|
|
5494
|
+
params = open_api_models.Params(
|
|
5495
|
+
action='DescribeRiskEventGroup',
|
|
5496
|
+
version='2017-12-07',
|
|
5497
|
+
protocol='HTTPS',
|
|
5498
|
+
pathname='/',
|
|
5499
|
+
method='POST',
|
|
5500
|
+
auth_type='AK',
|
|
5501
|
+
style='RPC',
|
|
5502
|
+
req_body_type='formData',
|
|
5503
|
+
body_type='json'
|
|
5504
|
+
)
|
|
5505
|
+
return TeaCore.from_map(
|
|
5506
|
+
cloudfw_20171207_models.DescribeRiskEventGroupResponse(),
|
|
5507
|
+
await self.call_api_async(params, req, runtime)
|
|
5508
|
+
)
|
|
5509
|
+
|
|
5510
|
+
def describe_risk_event_group(
|
|
5511
|
+
self,
|
|
5512
|
+
request: cloudfw_20171207_models.DescribeRiskEventGroupRequest,
|
|
5513
|
+
) -> cloudfw_20171207_models.DescribeRiskEventGroupResponse:
|
|
5514
|
+
"""
|
|
5515
|
+
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
5516
|
+
## Limits
|
|
5517
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5518
|
+
|
|
5519
|
+
@param request: DescribeRiskEventGroupRequest
|
|
5520
|
+
@return: DescribeRiskEventGroupResponse
|
|
5521
|
+
"""
|
|
5522
|
+
runtime = util_models.RuntimeOptions()
|
|
5523
|
+
return self.describe_risk_event_group_with_options(request, runtime)
|
|
5524
|
+
|
|
5525
|
+
async def describe_risk_event_group_async(
|
|
5526
|
+
self,
|
|
5527
|
+
request: cloudfw_20171207_models.DescribeRiskEventGroupRequest,
|
|
5528
|
+
) -> cloudfw_20171207_models.DescribeRiskEventGroupResponse:
|
|
5529
|
+
"""
|
|
5530
|
+
You can call the DescribeRiskEventGroup operation to query and download the details of intrusion events. We recommend that you query the details of 5 to 10 intrusion events at a time. If you do not need to query the geographical information about IP addresses, you can set the NoLocation parameter to true to prevent query timeout.
|
|
5531
|
+
## Limits
|
|
5532
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5533
|
+
|
|
5534
|
+
@param request: DescribeRiskEventGroupRequest
|
|
5535
|
+
@return: DescribeRiskEventGroupResponse
|
|
5536
|
+
"""
|
|
5537
|
+
runtime = util_models.RuntimeOptions()
|
|
5538
|
+
return await self.describe_risk_event_group_with_options_async(request, runtime)
|
|
5539
|
+
|
|
5540
|
+
def describe_risk_event_payload_with_options(
|
|
5541
|
+
self,
|
|
5542
|
+
request: cloudfw_20171207_models.DescribeRiskEventPayloadRequest,
|
|
5543
|
+
runtime: util_models.RuntimeOptions,
|
|
5544
|
+
) -> cloudfw_20171207_models.DescribeRiskEventPayloadResponse:
|
|
5545
|
+
UtilClient.validate_model(request)
|
|
5546
|
+
query = {}
|
|
5547
|
+
if not UtilClient.is_unset(request.dst_ip):
|
|
5548
|
+
query['DstIP'] = request.dst_ip
|
|
5549
|
+
if not UtilClient.is_unset(request.dst_vpc_id):
|
|
5550
|
+
query['DstVpcId'] = request.dst_vpc_id
|
|
5551
|
+
if not UtilClient.is_unset(request.end_time):
|
|
5552
|
+
query['EndTime'] = request.end_time
|
|
5553
|
+
if not UtilClient.is_unset(request.firewall_type):
|
|
5554
|
+
query['FirewallType'] = request.firewall_type
|
|
5555
|
+
if not UtilClient.is_unset(request.public_ip):
|
|
5556
|
+
query['PublicIP'] = request.public_ip
|
|
5557
|
+
if not UtilClient.is_unset(request.src_ip):
|
|
5558
|
+
query['SrcIP'] = request.src_ip
|
|
5559
|
+
if not UtilClient.is_unset(request.src_vpc_id):
|
|
5560
|
+
query['SrcVpcId'] = request.src_vpc_id
|
|
5561
|
+
if not UtilClient.is_unset(request.start_time):
|
|
5562
|
+
query['StartTime'] = request.start_time
|
|
5563
|
+
if not UtilClient.is_unset(request.uuid):
|
|
5564
|
+
query['UUID'] = request.uuid
|
|
5565
|
+
req = open_api_models.OpenApiRequest(
|
|
5566
|
+
query=OpenApiUtilClient.query(query)
|
|
5567
|
+
)
|
|
5568
|
+
params = open_api_models.Params(
|
|
5569
|
+
action='DescribeRiskEventPayload',
|
|
4556
5570
|
version='2017-12-07',
|
|
4557
5571
|
protocol='HTTPS',
|
|
4558
5572
|
pathname='/',
|
|
@@ -4596,7 +5610,233 @@ class Client(OpenApiClient):
|
|
|
4596
5610
|
query=OpenApiUtilClient.query(query)
|
|
4597
5611
|
)
|
|
4598
5612
|
params = open_api_models.Params(
|
|
4599
|
-
action='DescribeRiskEventPayload',
|
|
5613
|
+
action='DescribeRiskEventPayload',
|
|
5614
|
+
version='2017-12-07',
|
|
5615
|
+
protocol='HTTPS',
|
|
5616
|
+
pathname='/',
|
|
5617
|
+
method='POST',
|
|
5618
|
+
auth_type='AK',
|
|
5619
|
+
style='RPC',
|
|
5620
|
+
req_body_type='formData',
|
|
5621
|
+
body_type='json'
|
|
5622
|
+
)
|
|
5623
|
+
return TeaCore.from_map(
|
|
5624
|
+
cloudfw_20171207_models.DescribeRiskEventPayloadResponse(),
|
|
5625
|
+
await self.call_api_async(params, req, runtime)
|
|
5626
|
+
)
|
|
5627
|
+
|
|
5628
|
+
def describe_risk_event_payload(
|
|
5629
|
+
self,
|
|
5630
|
+
request: cloudfw_20171207_models.DescribeRiskEventPayloadRequest,
|
|
5631
|
+
) -> cloudfw_20171207_models.DescribeRiskEventPayloadResponse:
|
|
5632
|
+
runtime = util_models.RuntimeOptions()
|
|
5633
|
+
return self.describe_risk_event_payload_with_options(request, runtime)
|
|
5634
|
+
|
|
5635
|
+
async def describe_risk_event_payload_async(
|
|
5636
|
+
self,
|
|
5637
|
+
request: cloudfw_20171207_models.DescribeRiskEventPayloadRequest,
|
|
5638
|
+
) -> cloudfw_20171207_models.DescribeRiskEventPayloadResponse:
|
|
5639
|
+
runtime = util_models.RuntimeOptions()
|
|
5640
|
+
return await self.describe_risk_event_payload_with_options_async(request, runtime)
|
|
5641
|
+
|
|
5642
|
+
def describe_signature_lib_version_with_options(
|
|
5643
|
+
self,
|
|
5644
|
+
runtime: util_models.RuntimeOptions,
|
|
5645
|
+
) -> cloudfw_20171207_models.DescribeSignatureLibVersionResponse:
|
|
5646
|
+
req = open_api_models.OpenApiRequest()
|
|
5647
|
+
params = open_api_models.Params(
|
|
5648
|
+
action='DescribeSignatureLibVersion',
|
|
5649
|
+
version='2017-12-07',
|
|
5650
|
+
protocol='HTTPS',
|
|
5651
|
+
pathname='/',
|
|
5652
|
+
method='GET',
|
|
5653
|
+
auth_type='AK',
|
|
5654
|
+
style='RPC',
|
|
5655
|
+
req_body_type='formData',
|
|
5656
|
+
body_type='json'
|
|
5657
|
+
)
|
|
5658
|
+
return TeaCore.from_map(
|
|
5659
|
+
cloudfw_20171207_models.DescribeSignatureLibVersionResponse(),
|
|
5660
|
+
self.call_api(params, req, runtime)
|
|
5661
|
+
)
|
|
5662
|
+
|
|
5663
|
+
async def describe_signature_lib_version_with_options_async(
|
|
5664
|
+
self,
|
|
5665
|
+
runtime: util_models.RuntimeOptions,
|
|
5666
|
+
) -> cloudfw_20171207_models.DescribeSignatureLibVersionResponse:
|
|
5667
|
+
req = open_api_models.OpenApiRequest()
|
|
5668
|
+
params = open_api_models.Params(
|
|
5669
|
+
action='DescribeSignatureLibVersion',
|
|
5670
|
+
version='2017-12-07',
|
|
5671
|
+
protocol='HTTPS',
|
|
5672
|
+
pathname='/',
|
|
5673
|
+
method='GET',
|
|
5674
|
+
auth_type='AK',
|
|
5675
|
+
style='RPC',
|
|
5676
|
+
req_body_type='formData',
|
|
5677
|
+
body_type='json'
|
|
5678
|
+
)
|
|
5679
|
+
return TeaCore.from_map(
|
|
5680
|
+
cloudfw_20171207_models.DescribeSignatureLibVersionResponse(),
|
|
5681
|
+
await self.call_api_async(params, req, runtime)
|
|
5682
|
+
)
|
|
5683
|
+
|
|
5684
|
+
def describe_signature_lib_version(self) -> cloudfw_20171207_models.DescribeSignatureLibVersionResponse:
|
|
5685
|
+
runtime = util_models.RuntimeOptions()
|
|
5686
|
+
return self.describe_signature_lib_version_with_options(runtime)
|
|
5687
|
+
|
|
5688
|
+
async def describe_signature_lib_version_async(self) -> cloudfw_20171207_models.DescribeSignatureLibVersionResponse:
|
|
5689
|
+
runtime = util_models.RuntimeOptions()
|
|
5690
|
+
return await self.describe_signature_lib_version_with_options_async(runtime)
|
|
5691
|
+
|
|
5692
|
+
def describe_tr_firewall_policy_back_up_association_list_with_options(
|
|
5693
|
+
self,
|
|
5694
|
+
tmp_req: cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListRequest,
|
|
5695
|
+
runtime: util_models.RuntimeOptions,
|
|
5696
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListResponse:
|
|
5697
|
+
UtilClient.validate_model(tmp_req)
|
|
5698
|
+
request = cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListShrinkRequest()
|
|
5699
|
+
OpenApiUtilClient.convert(tmp_req, request)
|
|
5700
|
+
if not UtilClient.is_unset(tmp_req.candidate_list):
|
|
5701
|
+
request.candidate_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.candidate_list, 'CandidateList', 'json')
|
|
5702
|
+
query = {}
|
|
5703
|
+
if not UtilClient.is_unset(request.candidate_list_shrink):
|
|
5704
|
+
query['CandidateList'] = request.candidate_list_shrink
|
|
5705
|
+
if not UtilClient.is_unset(request.firewall_id):
|
|
5706
|
+
query['FirewallId'] = request.firewall_id
|
|
5707
|
+
if not UtilClient.is_unset(request.lang):
|
|
5708
|
+
query['Lang'] = request.lang
|
|
5709
|
+
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
5710
|
+
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
5711
|
+
req = open_api_models.OpenApiRequest(
|
|
5712
|
+
query=OpenApiUtilClient.query(query)
|
|
5713
|
+
)
|
|
5714
|
+
params = open_api_models.Params(
|
|
5715
|
+
action='DescribeTrFirewallPolicyBackUpAssociationList',
|
|
5716
|
+
version='2017-12-07',
|
|
5717
|
+
protocol='HTTPS',
|
|
5718
|
+
pathname='/',
|
|
5719
|
+
method='POST',
|
|
5720
|
+
auth_type='AK',
|
|
5721
|
+
style='RPC',
|
|
5722
|
+
req_body_type='formData',
|
|
5723
|
+
body_type='json'
|
|
5724
|
+
)
|
|
5725
|
+
return TeaCore.from_map(
|
|
5726
|
+
cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListResponse(),
|
|
5727
|
+
self.call_api(params, req, runtime)
|
|
5728
|
+
)
|
|
5729
|
+
|
|
5730
|
+
async def describe_tr_firewall_policy_back_up_association_list_with_options_async(
|
|
5731
|
+
self,
|
|
5732
|
+
tmp_req: cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListRequest,
|
|
5733
|
+
runtime: util_models.RuntimeOptions,
|
|
5734
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListResponse:
|
|
5735
|
+
UtilClient.validate_model(tmp_req)
|
|
5736
|
+
request = cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListShrinkRequest()
|
|
5737
|
+
OpenApiUtilClient.convert(tmp_req, request)
|
|
5738
|
+
if not UtilClient.is_unset(tmp_req.candidate_list):
|
|
5739
|
+
request.candidate_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.candidate_list, 'CandidateList', 'json')
|
|
5740
|
+
query = {}
|
|
5741
|
+
if not UtilClient.is_unset(request.candidate_list_shrink):
|
|
5742
|
+
query['CandidateList'] = request.candidate_list_shrink
|
|
5743
|
+
if not UtilClient.is_unset(request.firewall_id):
|
|
5744
|
+
query['FirewallId'] = request.firewall_id
|
|
5745
|
+
if not UtilClient.is_unset(request.lang):
|
|
5746
|
+
query['Lang'] = request.lang
|
|
5747
|
+
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
5748
|
+
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
5749
|
+
req = open_api_models.OpenApiRequest(
|
|
5750
|
+
query=OpenApiUtilClient.query(query)
|
|
5751
|
+
)
|
|
5752
|
+
params = open_api_models.Params(
|
|
5753
|
+
action='DescribeTrFirewallPolicyBackUpAssociationList',
|
|
5754
|
+
version='2017-12-07',
|
|
5755
|
+
protocol='HTTPS',
|
|
5756
|
+
pathname='/',
|
|
5757
|
+
method='POST',
|
|
5758
|
+
auth_type='AK',
|
|
5759
|
+
style='RPC',
|
|
5760
|
+
req_body_type='formData',
|
|
5761
|
+
body_type='json'
|
|
5762
|
+
)
|
|
5763
|
+
return TeaCore.from_map(
|
|
5764
|
+
cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListResponse(),
|
|
5765
|
+
await self.call_api_async(params, req, runtime)
|
|
5766
|
+
)
|
|
5767
|
+
|
|
5768
|
+
def describe_tr_firewall_policy_back_up_association_list(
|
|
5769
|
+
self,
|
|
5770
|
+
request: cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListRequest,
|
|
5771
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListResponse:
|
|
5772
|
+
runtime = util_models.RuntimeOptions()
|
|
5773
|
+
return self.describe_tr_firewall_policy_back_up_association_list_with_options(request, runtime)
|
|
5774
|
+
|
|
5775
|
+
async def describe_tr_firewall_policy_back_up_association_list_async(
|
|
5776
|
+
self,
|
|
5777
|
+
request: cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListRequest,
|
|
5778
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallPolicyBackUpAssociationListResponse:
|
|
5779
|
+
runtime = util_models.RuntimeOptions()
|
|
5780
|
+
return await self.describe_tr_firewall_policy_back_up_association_list_with_options_async(request, runtime)
|
|
5781
|
+
|
|
5782
|
+
def describe_tr_firewall_v2route_policy_list_with_options(
|
|
5783
|
+
self,
|
|
5784
|
+
request: cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListRequest,
|
|
5785
|
+
runtime: util_models.RuntimeOptions,
|
|
5786
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListResponse:
|
|
5787
|
+
UtilClient.validate_model(request)
|
|
5788
|
+
query = {}
|
|
5789
|
+
if not UtilClient.is_unset(request.current_page):
|
|
5790
|
+
query['CurrentPage'] = request.current_page
|
|
5791
|
+
if not UtilClient.is_unset(request.firewall_id):
|
|
5792
|
+
query['FirewallId'] = request.firewall_id
|
|
5793
|
+
if not UtilClient.is_unset(request.lang):
|
|
5794
|
+
query['Lang'] = request.lang
|
|
5795
|
+
if not UtilClient.is_unset(request.page_size):
|
|
5796
|
+
query['PageSize'] = request.page_size
|
|
5797
|
+
if not UtilClient.is_unset(request.policy_id):
|
|
5798
|
+
query['PolicyId'] = request.policy_id
|
|
5799
|
+
req = open_api_models.OpenApiRequest(
|
|
5800
|
+
query=OpenApiUtilClient.query(query)
|
|
5801
|
+
)
|
|
5802
|
+
params = open_api_models.Params(
|
|
5803
|
+
action='DescribeTrFirewallV2RoutePolicyList',
|
|
5804
|
+
version='2017-12-07',
|
|
5805
|
+
protocol='HTTPS',
|
|
5806
|
+
pathname='/',
|
|
5807
|
+
method='POST',
|
|
5808
|
+
auth_type='AK',
|
|
5809
|
+
style='RPC',
|
|
5810
|
+
req_body_type='formData',
|
|
5811
|
+
body_type='json'
|
|
5812
|
+
)
|
|
5813
|
+
return TeaCore.from_map(
|
|
5814
|
+
cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListResponse(),
|
|
5815
|
+
self.call_api(params, req, runtime)
|
|
5816
|
+
)
|
|
5817
|
+
|
|
5818
|
+
async def describe_tr_firewall_v2route_policy_list_with_options_async(
|
|
5819
|
+
self,
|
|
5820
|
+
request: cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListRequest,
|
|
5821
|
+
runtime: util_models.RuntimeOptions,
|
|
5822
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListResponse:
|
|
5823
|
+
UtilClient.validate_model(request)
|
|
5824
|
+
query = {}
|
|
5825
|
+
if not UtilClient.is_unset(request.current_page):
|
|
5826
|
+
query['CurrentPage'] = request.current_page
|
|
5827
|
+
if not UtilClient.is_unset(request.firewall_id):
|
|
5828
|
+
query['FirewallId'] = request.firewall_id
|
|
5829
|
+
if not UtilClient.is_unset(request.lang):
|
|
5830
|
+
query['Lang'] = request.lang
|
|
5831
|
+
if not UtilClient.is_unset(request.page_size):
|
|
5832
|
+
query['PageSize'] = request.page_size
|
|
5833
|
+
if not UtilClient.is_unset(request.policy_id):
|
|
5834
|
+
query['PolicyId'] = request.policy_id
|
|
5835
|
+
req = open_api_models.OpenApiRequest(
|
|
5836
|
+
query=OpenApiUtilClient.query(query)
|
|
5837
|
+
)
|
|
5838
|
+
params = open_api_models.Params(
|
|
5839
|
+
action='DescribeTrFirewallV2RoutePolicyList',
|
|
4600
5840
|
version='2017-12-07',
|
|
4601
5841
|
protocol='HTTPS',
|
|
4602
5842
|
pathname='/',
|
|
@@ -4607,42 +5847,40 @@ class Client(OpenApiClient):
|
|
|
4607
5847
|
body_type='json'
|
|
4608
5848
|
)
|
|
4609
5849
|
return TeaCore.from_map(
|
|
4610
|
-
cloudfw_20171207_models.
|
|
5850
|
+
cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListResponse(),
|
|
4611
5851
|
await self.call_api_async(params, req, runtime)
|
|
4612
5852
|
)
|
|
4613
5853
|
|
|
4614
|
-
def
|
|
5854
|
+
def describe_tr_firewall_v2route_policy_list(
|
|
4615
5855
|
self,
|
|
4616
|
-
request: cloudfw_20171207_models.
|
|
4617
|
-
) -> cloudfw_20171207_models.
|
|
5856
|
+
request: cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListRequest,
|
|
5857
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListResponse:
|
|
4618
5858
|
runtime = util_models.RuntimeOptions()
|
|
4619
|
-
return self.
|
|
5859
|
+
return self.describe_tr_firewall_v2route_policy_list_with_options(request, runtime)
|
|
4620
5860
|
|
|
4621
|
-
async def
|
|
5861
|
+
async def describe_tr_firewall_v2route_policy_list_async(
|
|
4622
5862
|
self,
|
|
4623
|
-
request: cloudfw_20171207_models.
|
|
4624
|
-
) -> cloudfw_20171207_models.
|
|
5863
|
+
request: cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListRequest,
|
|
5864
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallV2RoutePolicyListResponse:
|
|
4625
5865
|
runtime = util_models.RuntimeOptions()
|
|
4626
|
-
return await self.
|
|
5866
|
+
return await self.describe_tr_firewall_v2route_policy_list_with_options_async(request, runtime)
|
|
4627
5867
|
|
|
4628
|
-
def
|
|
5868
|
+
def describe_tr_firewalls_v2detail_with_options(
|
|
4629
5869
|
self,
|
|
4630
|
-
request: cloudfw_20171207_models.
|
|
5870
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2DetailRequest,
|
|
4631
5871
|
runtime: util_models.RuntimeOptions,
|
|
4632
|
-
) -> cloudfw_20171207_models.
|
|
5872
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2DetailResponse:
|
|
4633
5873
|
UtilClient.validate_model(request)
|
|
4634
5874
|
query = {}
|
|
4635
5875
|
if not UtilClient.is_unset(request.firewall_id):
|
|
4636
5876
|
query['FirewallId'] = request.firewall_id
|
|
4637
5877
|
if not UtilClient.is_unset(request.lang):
|
|
4638
5878
|
query['Lang'] = request.lang
|
|
4639
|
-
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
4640
|
-
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
4641
5879
|
req = open_api_models.OpenApiRequest(
|
|
4642
5880
|
query=OpenApiUtilClient.query(query)
|
|
4643
5881
|
)
|
|
4644
5882
|
params = open_api_models.Params(
|
|
4645
|
-
action='
|
|
5883
|
+
action='DescribeTrFirewallsV2Detail',
|
|
4646
5884
|
version='2017-12-07',
|
|
4647
5885
|
protocol='HTTPS',
|
|
4648
5886
|
pathname='/',
|
|
@@ -4653,28 +5891,26 @@ class Client(OpenApiClient):
|
|
|
4653
5891
|
body_type='json'
|
|
4654
5892
|
)
|
|
4655
5893
|
return TeaCore.from_map(
|
|
4656
|
-
cloudfw_20171207_models.
|
|
5894
|
+
cloudfw_20171207_models.DescribeTrFirewallsV2DetailResponse(),
|
|
4657
5895
|
self.call_api(params, req, runtime)
|
|
4658
5896
|
)
|
|
4659
5897
|
|
|
4660
|
-
async def
|
|
5898
|
+
async def describe_tr_firewalls_v2detail_with_options_async(
|
|
4661
5899
|
self,
|
|
4662
|
-
request: cloudfw_20171207_models.
|
|
5900
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2DetailRequest,
|
|
4663
5901
|
runtime: util_models.RuntimeOptions,
|
|
4664
|
-
) -> cloudfw_20171207_models.
|
|
5902
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2DetailResponse:
|
|
4665
5903
|
UtilClient.validate_model(request)
|
|
4666
5904
|
query = {}
|
|
4667
5905
|
if not UtilClient.is_unset(request.firewall_id):
|
|
4668
5906
|
query['FirewallId'] = request.firewall_id
|
|
4669
5907
|
if not UtilClient.is_unset(request.lang):
|
|
4670
5908
|
query['Lang'] = request.lang
|
|
4671
|
-
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
4672
|
-
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
4673
5909
|
req = open_api_models.OpenApiRequest(
|
|
4674
5910
|
query=OpenApiUtilClient.query(query)
|
|
4675
5911
|
)
|
|
4676
5912
|
params = open_api_models.Params(
|
|
4677
|
-
action='
|
|
5913
|
+
action='DescribeTrFirewallsV2Detail',
|
|
4678
5914
|
version='2017-12-07',
|
|
4679
5915
|
protocol='HTTPS',
|
|
4680
5916
|
pathname='/',
|
|
@@ -4685,46 +5921,58 @@ class Client(OpenApiClient):
|
|
|
4685
5921
|
body_type='json'
|
|
4686
5922
|
)
|
|
4687
5923
|
return TeaCore.from_map(
|
|
4688
|
-
cloudfw_20171207_models.
|
|
5924
|
+
cloudfw_20171207_models.DescribeTrFirewallsV2DetailResponse(),
|
|
4689
5925
|
await self.call_api_async(params, req, runtime)
|
|
4690
5926
|
)
|
|
4691
5927
|
|
|
4692
|
-
def
|
|
5928
|
+
def describe_tr_firewalls_v2detail(
|
|
4693
5929
|
self,
|
|
4694
|
-
request: cloudfw_20171207_models.
|
|
4695
|
-
) -> cloudfw_20171207_models.
|
|
5930
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2DetailRequest,
|
|
5931
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2DetailResponse:
|
|
4696
5932
|
runtime = util_models.RuntimeOptions()
|
|
4697
|
-
return self.
|
|
5933
|
+
return self.describe_tr_firewalls_v2detail_with_options(request, runtime)
|
|
4698
5934
|
|
|
4699
|
-
async def
|
|
5935
|
+
async def describe_tr_firewalls_v2detail_async(
|
|
4700
5936
|
self,
|
|
4701
|
-
request: cloudfw_20171207_models.
|
|
4702
|
-
) -> cloudfw_20171207_models.
|
|
5937
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2DetailRequest,
|
|
5938
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2DetailResponse:
|
|
4703
5939
|
runtime = util_models.RuntimeOptions()
|
|
4704
|
-
return await self.
|
|
5940
|
+
return await self.describe_tr_firewalls_v2detail_with_options_async(request, runtime)
|
|
4705
5941
|
|
|
4706
|
-
def
|
|
5942
|
+
def describe_tr_firewalls_v2list_with_options(
|
|
4707
5943
|
self,
|
|
4708
|
-
request: cloudfw_20171207_models.
|
|
5944
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2ListRequest,
|
|
4709
5945
|
runtime: util_models.RuntimeOptions,
|
|
4710
|
-
) -> cloudfw_20171207_models.
|
|
5946
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2ListResponse:
|
|
4711
5947
|
UtilClient.validate_model(request)
|
|
4712
5948
|
query = {}
|
|
5949
|
+
if not UtilClient.is_unset(request.cen_id):
|
|
5950
|
+
query['CenId'] = request.cen_id
|
|
4713
5951
|
if not UtilClient.is_unset(request.current_page):
|
|
4714
5952
|
query['CurrentPage'] = request.current_page
|
|
4715
5953
|
if not UtilClient.is_unset(request.firewall_id):
|
|
4716
5954
|
query['FirewallId'] = request.firewall_id
|
|
5955
|
+
if not UtilClient.is_unset(request.firewall_name):
|
|
5956
|
+
query['FirewallName'] = request.firewall_name
|
|
5957
|
+
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
5958
|
+
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
4717
5959
|
if not UtilClient.is_unset(request.lang):
|
|
4718
5960
|
query['Lang'] = request.lang
|
|
5961
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
5962
|
+
query['OwnerId'] = request.owner_id
|
|
4719
5963
|
if not UtilClient.is_unset(request.page_size):
|
|
4720
5964
|
query['PageSize'] = request.page_size
|
|
4721
|
-
if not UtilClient.is_unset(request.
|
|
4722
|
-
query['
|
|
5965
|
+
if not UtilClient.is_unset(request.region_no):
|
|
5966
|
+
query['RegionNo'] = request.region_no
|
|
5967
|
+
if not UtilClient.is_unset(request.route_mode):
|
|
5968
|
+
query['RouteMode'] = request.route_mode
|
|
5969
|
+
if not UtilClient.is_unset(request.transit_router_id):
|
|
5970
|
+
query['TransitRouterId'] = request.transit_router_id
|
|
4723
5971
|
req = open_api_models.OpenApiRequest(
|
|
4724
5972
|
query=OpenApiUtilClient.query(query)
|
|
4725
5973
|
)
|
|
4726
5974
|
params = open_api_models.Params(
|
|
4727
|
-
action='
|
|
5975
|
+
action='DescribeTrFirewallsV2List',
|
|
4728
5976
|
version='2017-12-07',
|
|
4729
5977
|
protocol='HTTPS',
|
|
4730
5978
|
pathname='/',
|
|
@@ -4735,32 +5983,44 @@ class Client(OpenApiClient):
|
|
|
4735
5983
|
body_type='json'
|
|
4736
5984
|
)
|
|
4737
5985
|
return TeaCore.from_map(
|
|
4738
|
-
cloudfw_20171207_models.
|
|
5986
|
+
cloudfw_20171207_models.DescribeTrFirewallsV2ListResponse(),
|
|
4739
5987
|
self.call_api(params, req, runtime)
|
|
4740
5988
|
)
|
|
4741
5989
|
|
|
4742
|
-
async def
|
|
5990
|
+
async def describe_tr_firewalls_v2list_with_options_async(
|
|
4743
5991
|
self,
|
|
4744
|
-
request: cloudfw_20171207_models.
|
|
5992
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2ListRequest,
|
|
4745
5993
|
runtime: util_models.RuntimeOptions,
|
|
4746
|
-
) -> cloudfw_20171207_models.
|
|
5994
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2ListResponse:
|
|
4747
5995
|
UtilClient.validate_model(request)
|
|
4748
5996
|
query = {}
|
|
5997
|
+
if not UtilClient.is_unset(request.cen_id):
|
|
5998
|
+
query['CenId'] = request.cen_id
|
|
4749
5999
|
if not UtilClient.is_unset(request.current_page):
|
|
4750
6000
|
query['CurrentPage'] = request.current_page
|
|
4751
6001
|
if not UtilClient.is_unset(request.firewall_id):
|
|
4752
6002
|
query['FirewallId'] = request.firewall_id
|
|
6003
|
+
if not UtilClient.is_unset(request.firewall_name):
|
|
6004
|
+
query['FirewallName'] = request.firewall_name
|
|
6005
|
+
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
6006
|
+
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
4753
6007
|
if not UtilClient.is_unset(request.lang):
|
|
4754
6008
|
query['Lang'] = request.lang
|
|
6009
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
6010
|
+
query['OwnerId'] = request.owner_id
|
|
4755
6011
|
if not UtilClient.is_unset(request.page_size):
|
|
4756
6012
|
query['PageSize'] = request.page_size
|
|
4757
|
-
if not UtilClient.is_unset(request.
|
|
4758
|
-
query['
|
|
6013
|
+
if not UtilClient.is_unset(request.region_no):
|
|
6014
|
+
query['RegionNo'] = request.region_no
|
|
6015
|
+
if not UtilClient.is_unset(request.route_mode):
|
|
6016
|
+
query['RouteMode'] = request.route_mode
|
|
6017
|
+
if not UtilClient.is_unset(request.transit_router_id):
|
|
6018
|
+
query['TransitRouterId'] = request.transit_router_id
|
|
4759
6019
|
req = open_api_models.OpenApiRequest(
|
|
4760
6020
|
query=OpenApiUtilClient.query(query)
|
|
4761
6021
|
)
|
|
4762
6022
|
params = open_api_models.Params(
|
|
4763
|
-
action='
|
|
6023
|
+
action='DescribeTrFirewallsV2List',
|
|
4764
6024
|
version='2017-12-07',
|
|
4765
6025
|
protocol='HTTPS',
|
|
4766
6026
|
pathname='/',
|
|
@@ -4771,40 +6031,46 @@ class Client(OpenApiClient):
|
|
|
4771
6031
|
body_type='json'
|
|
4772
6032
|
)
|
|
4773
6033
|
return TeaCore.from_map(
|
|
4774
|
-
cloudfw_20171207_models.
|
|
6034
|
+
cloudfw_20171207_models.DescribeTrFirewallsV2ListResponse(),
|
|
4775
6035
|
await self.call_api_async(params, req, runtime)
|
|
4776
6036
|
)
|
|
4777
6037
|
|
|
4778
|
-
def
|
|
6038
|
+
def describe_tr_firewalls_v2list(
|
|
4779
6039
|
self,
|
|
4780
|
-
request: cloudfw_20171207_models.
|
|
4781
|
-
) -> cloudfw_20171207_models.
|
|
6040
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2ListRequest,
|
|
6041
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2ListResponse:
|
|
4782
6042
|
runtime = util_models.RuntimeOptions()
|
|
4783
|
-
return self.
|
|
6043
|
+
return self.describe_tr_firewalls_v2list_with_options(request, runtime)
|
|
4784
6044
|
|
|
4785
|
-
async def
|
|
6045
|
+
async def describe_tr_firewalls_v2list_async(
|
|
4786
6046
|
self,
|
|
4787
|
-
request: cloudfw_20171207_models.
|
|
4788
|
-
) -> cloudfw_20171207_models.
|
|
6047
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2ListRequest,
|
|
6048
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2ListResponse:
|
|
4789
6049
|
runtime = util_models.RuntimeOptions()
|
|
4790
|
-
return await self.
|
|
6050
|
+
return await self.describe_tr_firewalls_v2list_with_options_async(request, runtime)
|
|
4791
6051
|
|
|
4792
|
-
def
|
|
6052
|
+
def describe_tr_firewalls_v2route_list_with_options(
|
|
4793
6053
|
self,
|
|
4794
|
-
request: cloudfw_20171207_models.
|
|
6054
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2RouteListRequest,
|
|
4795
6055
|
runtime: util_models.RuntimeOptions,
|
|
4796
|
-
) -> cloudfw_20171207_models.
|
|
6056
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2RouteListResponse:
|
|
4797
6057
|
UtilClient.validate_model(request)
|
|
4798
6058
|
query = {}
|
|
6059
|
+
if not UtilClient.is_unset(request.current_page):
|
|
6060
|
+
query['CurrentPage'] = request.current_page
|
|
4799
6061
|
if not UtilClient.is_unset(request.firewall_id):
|
|
4800
6062
|
query['FirewallId'] = request.firewall_id
|
|
4801
6063
|
if not UtilClient.is_unset(request.lang):
|
|
4802
6064
|
query['Lang'] = request.lang
|
|
6065
|
+
if not UtilClient.is_unset(request.page_size):
|
|
6066
|
+
query['PageSize'] = request.page_size
|
|
6067
|
+
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
6068
|
+
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
4803
6069
|
req = open_api_models.OpenApiRequest(
|
|
4804
6070
|
query=OpenApiUtilClient.query(query)
|
|
4805
6071
|
)
|
|
4806
6072
|
params = open_api_models.Params(
|
|
4807
|
-
action='
|
|
6073
|
+
action='DescribeTrFirewallsV2RouteList',
|
|
4808
6074
|
version='2017-12-07',
|
|
4809
6075
|
protocol='HTTPS',
|
|
4810
6076
|
pathname='/',
|
|
@@ -4815,26 +6081,32 @@ class Client(OpenApiClient):
|
|
|
4815
6081
|
body_type='json'
|
|
4816
6082
|
)
|
|
4817
6083
|
return TeaCore.from_map(
|
|
4818
|
-
cloudfw_20171207_models.
|
|
6084
|
+
cloudfw_20171207_models.DescribeTrFirewallsV2RouteListResponse(),
|
|
4819
6085
|
self.call_api(params, req, runtime)
|
|
4820
6086
|
)
|
|
4821
6087
|
|
|
4822
|
-
async def
|
|
6088
|
+
async def describe_tr_firewalls_v2route_list_with_options_async(
|
|
4823
6089
|
self,
|
|
4824
|
-
request: cloudfw_20171207_models.
|
|
6090
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2RouteListRequest,
|
|
4825
6091
|
runtime: util_models.RuntimeOptions,
|
|
4826
|
-
) -> cloudfw_20171207_models.
|
|
6092
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2RouteListResponse:
|
|
4827
6093
|
UtilClient.validate_model(request)
|
|
4828
6094
|
query = {}
|
|
6095
|
+
if not UtilClient.is_unset(request.current_page):
|
|
6096
|
+
query['CurrentPage'] = request.current_page
|
|
4829
6097
|
if not UtilClient.is_unset(request.firewall_id):
|
|
4830
6098
|
query['FirewallId'] = request.firewall_id
|
|
4831
6099
|
if not UtilClient.is_unset(request.lang):
|
|
4832
6100
|
query['Lang'] = request.lang
|
|
6101
|
+
if not UtilClient.is_unset(request.page_size):
|
|
6102
|
+
query['PageSize'] = request.page_size
|
|
6103
|
+
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
6104
|
+
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
4833
6105
|
req = open_api_models.OpenApiRequest(
|
|
4834
6106
|
query=OpenApiUtilClient.query(query)
|
|
4835
6107
|
)
|
|
4836
6108
|
params = open_api_models.Params(
|
|
4837
|
-
action='
|
|
6109
|
+
action='DescribeTrFirewallsV2RouteList',
|
|
4838
6110
|
version='2017-12-07',
|
|
4839
6111
|
protocol='HTTPS',
|
|
4840
6112
|
pathname='/',
|
|
@@ -4845,58 +6117,108 @@ class Client(OpenApiClient):
|
|
|
4845
6117
|
body_type='json'
|
|
4846
6118
|
)
|
|
4847
6119
|
return TeaCore.from_map(
|
|
4848
|
-
cloudfw_20171207_models.
|
|
6120
|
+
cloudfw_20171207_models.DescribeTrFirewallsV2RouteListResponse(),
|
|
4849
6121
|
await self.call_api_async(params, req, runtime)
|
|
4850
6122
|
)
|
|
4851
6123
|
|
|
4852
|
-
def
|
|
6124
|
+
def describe_tr_firewalls_v2route_list(
|
|
4853
6125
|
self,
|
|
4854
|
-
request: cloudfw_20171207_models.
|
|
4855
|
-
) -> cloudfw_20171207_models.
|
|
6126
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2RouteListRequest,
|
|
6127
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2RouteListResponse:
|
|
4856
6128
|
runtime = util_models.RuntimeOptions()
|
|
4857
|
-
return self.
|
|
6129
|
+
return self.describe_tr_firewalls_v2route_list_with_options(request, runtime)
|
|
4858
6130
|
|
|
4859
|
-
async def
|
|
6131
|
+
async def describe_tr_firewalls_v2route_list_async(
|
|
4860
6132
|
self,
|
|
4861
|
-
request: cloudfw_20171207_models.
|
|
4862
|
-
) -> cloudfw_20171207_models.
|
|
6133
|
+
request: cloudfw_20171207_models.DescribeTrFirewallsV2RouteListRequest,
|
|
6134
|
+
) -> cloudfw_20171207_models.DescribeTrFirewallsV2RouteListResponse:
|
|
6135
|
+
runtime = util_models.RuntimeOptions()
|
|
6136
|
+
return await self.describe_tr_firewalls_v2route_list_with_options_async(request, runtime)
|
|
6137
|
+
|
|
6138
|
+
def describe_user_asset_iptraffic_info_with_options(
|
|
6139
|
+
self,
|
|
6140
|
+
request: cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoRequest,
|
|
6141
|
+
runtime: util_models.RuntimeOptions,
|
|
6142
|
+
) -> cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoResponse:
|
|
6143
|
+
UtilClient.validate_model(request)
|
|
6144
|
+
query = OpenApiUtilClient.query(UtilClient.to_map(request))
|
|
6145
|
+
req = open_api_models.OpenApiRequest(
|
|
6146
|
+
query=OpenApiUtilClient.query(query)
|
|
6147
|
+
)
|
|
6148
|
+
params = open_api_models.Params(
|
|
6149
|
+
action='DescribeUserAssetIPTrafficInfo',
|
|
6150
|
+
version='2017-12-07',
|
|
6151
|
+
protocol='HTTPS',
|
|
6152
|
+
pathname='/',
|
|
6153
|
+
method='GET',
|
|
6154
|
+
auth_type='AK',
|
|
6155
|
+
style='RPC',
|
|
6156
|
+
req_body_type='formData',
|
|
6157
|
+
body_type='json'
|
|
6158
|
+
)
|
|
6159
|
+
return TeaCore.from_map(
|
|
6160
|
+
cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoResponse(),
|
|
6161
|
+
self.call_api(params, req, runtime)
|
|
6162
|
+
)
|
|
6163
|
+
|
|
6164
|
+
async def describe_user_asset_iptraffic_info_with_options_async(
|
|
6165
|
+
self,
|
|
6166
|
+
request: cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoRequest,
|
|
6167
|
+
runtime: util_models.RuntimeOptions,
|
|
6168
|
+
) -> cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoResponse:
|
|
6169
|
+
UtilClient.validate_model(request)
|
|
6170
|
+
query = OpenApiUtilClient.query(UtilClient.to_map(request))
|
|
6171
|
+
req = open_api_models.OpenApiRequest(
|
|
6172
|
+
query=OpenApiUtilClient.query(query)
|
|
6173
|
+
)
|
|
6174
|
+
params = open_api_models.Params(
|
|
6175
|
+
action='DescribeUserAssetIPTrafficInfo',
|
|
6176
|
+
version='2017-12-07',
|
|
6177
|
+
protocol='HTTPS',
|
|
6178
|
+
pathname='/',
|
|
6179
|
+
method='GET',
|
|
6180
|
+
auth_type='AK',
|
|
6181
|
+
style='RPC',
|
|
6182
|
+
req_body_type='formData',
|
|
6183
|
+
body_type='json'
|
|
6184
|
+
)
|
|
6185
|
+
return TeaCore.from_map(
|
|
6186
|
+
cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoResponse(),
|
|
6187
|
+
await self.call_api_async(params, req, runtime)
|
|
6188
|
+
)
|
|
6189
|
+
|
|
6190
|
+
def describe_user_asset_iptraffic_info(
|
|
6191
|
+
self,
|
|
6192
|
+
request: cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoRequest,
|
|
6193
|
+
) -> cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoResponse:
|
|
6194
|
+
runtime = util_models.RuntimeOptions()
|
|
6195
|
+
return self.describe_user_asset_iptraffic_info_with_options(request, runtime)
|
|
6196
|
+
|
|
6197
|
+
async def describe_user_asset_iptraffic_info_async(
|
|
6198
|
+
self,
|
|
6199
|
+
request: cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoRequest,
|
|
6200
|
+
) -> cloudfw_20171207_models.DescribeUserAssetIPTrafficInfoResponse:
|
|
4863
6201
|
runtime = util_models.RuntimeOptions()
|
|
4864
|
-
return await self.
|
|
6202
|
+
return await self.describe_user_asset_iptraffic_info_with_options_async(request, runtime)
|
|
4865
6203
|
|
|
4866
|
-
def
|
|
6204
|
+
def describe_user_ipswhitelist_with_options(
|
|
4867
6205
|
self,
|
|
4868
|
-
request: cloudfw_20171207_models.
|
|
6206
|
+
request: cloudfw_20171207_models.DescribeUserIPSWhitelistRequest,
|
|
4869
6207
|
runtime: util_models.RuntimeOptions,
|
|
4870
|
-
) -> cloudfw_20171207_models.
|
|
6208
|
+
) -> cloudfw_20171207_models.DescribeUserIPSWhitelistResponse:
|
|
4871
6209
|
UtilClient.validate_model(request)
|
|
4872
6210
|
query = {}
|
|
4873
|
-
if not UtilClient.is_unset(request.cen_id):
|
|
4874
|
-
query['CenId'] = request.cen_id
|
|
4875
|
-
if not UtilClient.is_unset(request.current_page):
|
|
4876
|
-
query['CurrentPage'] = request.current_page
|
|
4877
|
-
if not UtilClient.is_unset(request.firewall_id):
|
|
4878
|
-
query['FirewallId'] = request.firewall_id
|
|
4879
|
-
if not UtilClient.is_unset(request.firewall_name):
|
|
4880
|
-
query['FirewallName'] = request.firewall_name
|
|
4881
|
-
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
4882
|
-
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
4883
6211
|
if not UtilClient.is_unset(request.lang):
|
|
4884
6212
|
query['Lang'] = request.lang
|
|
4885
|
-
if not UtilClient.is_unset(request.
|
|
4886
|
-
query['
|
|
4887
|
-
if not UtilClient.is_unset(request.
|
|
4888
|
-
query['
|
|
4889
|
-
if not UtilClient.is_unset(request.region_no):
|
|
4890
|
-
query['RegionNo'] = request.region_no
|
|
4891
|
-
if not UtilClient.is_unset(request.route_mode):
|
|
4892
|
-
query['RouteMode'] = request.route_mode
|
|
4893
|
-
if not UtilClient.is_unset(request.transit_router_id):
|
|
4894
|
-
query['TransitRouterId'] = request.transit_router_id
|
|
6213
|
+
if not UtilClient.is_unset(request.lang):
|
|
6214
|
+
query['Lang'] = request.lang
|
|
6215
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
6216
|
+
query['SourceIp'] = request.source_ip
|
|
4895
6217
|
req = open_api_models.OpenApiRequest(
|
|
4896
6218
|
query=OpenApiUtilClient.query(query)
|
|
4897
6219
|
)
|
|
4898
6220
|
params = open_api_models.Params(
|
|
4899
|
-
action='
|
|
6221
|
+
action='DescribeUserIPSWhitelist',
|
|
4900
6222
|
version='2017-12-07',
|
|
4901
6223
|
protocol='HTTPS',
|
|
4902
6224
|
pathname='/',
|
|
@@ -4907,44 +6229,28 @@ class Client(OpenApiClient):
|
|
|
4907
6229
|
body_type='json'
|
|
4908
6230
|
)
|
|
4909
6231
|
return TeaCore.from_map(
|
|
4910
|
-
cloudfw_20171207_models.
|
|
6232
|
+
cloudfw_20171207_models.DescribeUserIPSWhitelistResponse(),
|
|
4911
6233
|
self.call_api(params, req, runtime)
|
|
4912
6234
|
)
|
|
4913
6235
|
|
|
4914
|
-
async def
|
|
6236
|
+
async def describe_user_ipswhitelist_with_options_async(
|
|
4915
6237
|
self,
|
|
4916
|
-
request: cloudfw_20171207_models.
|
|
6238
|
+
request: cloudfw_20171207_models.DescribeUserIPSWhitelistRequest,
|
|
4917
6239
|
runtime: util_models.RuntimeOptions,
|
|
4918
|
-
) -> cloudfw_20171207_models.
|
|
6240
|
+
) -> cloudfw_20171207_models.DescribeUserIPSWhitelistResponse:
|
|
4919
6241
|
UtilClient.validate_model(request)
|
|
4920
6242
|
query = {}
|
|
4921
|
-
if not UtilClient.is_unset(request.cen_id):
|
|
4922
|
-
query['CenId'] = request.cen_id
|
|
4923
|
-
if not UtilClient.is_unset(request.current_page):
|
|
4924
|
-
query['CurrentPage'] = request.current_page
|
|
4925
|
-
if not UtilClient.is_unset(request.firewall_id):
|
|
4926
|
-
query['FirewallId'] = request.firewall_id
|
|
4927
|
-
if not UtilClient.is_unset(request.firewall_name):
|
|
4928
|
-
query['FirewallName'] = request.firewall_name
|
|
4929
|
-
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
4930
|
-
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
4931
6243
|
if not UtilClient.is_unset(request.lang):
|
|
4932
6244
|
query['Lang'] = request.lang
|
|
4933
|
-
if not UtilClient.is_unset(request.
|
|
4934
|
-
query['
|
|
4935
|
-
if not UtilClient.is_unset(request.
|
|
4936
|
-
query['
|
|
4937
|
-
if not UtilClient.is_unset(request.region_no):
|
|
4938
|
-
query['RegionNo'] = request.region_no
|
|
4939
|
-
if not UtilClient.is_unset(request.route_mode):
|
|
4940
|
-
query['RouteMode'] = request.route_mode
|
|
4941
|
-
if not UtilClient.is_unset(request.transit_router_id):
|
|
4942
|
-
query['TransitRouterId'] = request.transit_router_id
|
|
6245
|
+
if not UtilClient.is_unset(request.lang):
|
|
6246
|
+
query['Lang'] = request.lang
|
|
6247
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
6248
|
+
query['SourceIp'] = request.source_ip
|
|
4943
6249
|
req = open_api_models.OpenApiRequest(
|
|
4944
6250
|
query=OpenApiUtilClient.query(query)
|
|
4945
6251
|
)
|
|
4946
6252
|
params = open_api_models.Params(
|
|
4947
|
-
action='
|
|
6253
|
+
action='DescribeUserIPSWhitelist',
|
|
4948
6254
|
version='2017-12-07',
|
|
4949
6255
|
protocol='HTTPS',
|
|
4950
6256
|
pathname='/',
|
|
@@ -4955,46 +6261,53 @@ class Client(OpenApiClient):
|
|
|
4955
6261
|
body_type='json'
|
|
4956
6262
|
)
|
|
4957
6263
|
return TeaCore.from_map(
|
|
4958
|
-
cloudfw_20171207_models.
|
|
6264
|
+
cloudfw_20171207_models.DescribeUserIPSWhitelistResponse(),
|
|
4959
6265
|
await self.call_api_async(params, req, runtime)
|
|
4960
6266
|
)
|
|
4961
6267
|
|
|
4962
|
-
def
|
|
6268
|
+
def describe_user_ipswhitelist(
|
|
4963
6269
|
self,
|
|
4964
|
-
request: cloudfw_20171207_models.
|
|
4965
|
-
) -> cloudfw_20171207_models.
|
|
6270
|
+
request: cloudfw_20171207_models.DescribeUserIPSWhitelistRequest,
|
|
6271
|
+
) -> cloudfw_20171207_models.DescribeUserIPSWhitelistResponse:
|
|
4966
6272
|
runtime = util_models.RuntimeOptions()
|
|
4967
|
-
return self.
|
|
6273
|
+
return self.describe_user_ipswhitelist_with_options(request, runtime)
|
|
4968
6274
|
|
|
4969
|
-
async def
|
|
6275
|
+
async def describe_user_ipswhitelist_async(
|
|
4970
6276
|
self,
|
|
4971
|
-
request: cloudfw_20171207_models.
|
|
4972
|
-
) -> cloudfw_20171207_models.
|
|
6277
|
+
request: cloudfw_20171207_models.DescribeUserIPSWhitelistRequest,
|
|
6278
|
+
) -> cloudfw_20171207_models.DescribeUserIPSWhitelistResponse:
|
|
4973
6279
|
runtime = util_models.RuntimeOptions()
|
|
4974
|
-
return await self.
|
|
6280
|
+
return await self.describe_user_ipswhitelist_with_options_async(request, runtime)
|
|
4975
6281
|
|
|
4976
|
-
def
|
|
6282
|
+
def describe_vpc_firewall_acl_group_list_with_options(
|
|
4977
6283
|
self,
|
|
4978
|
-
request: cloudfw_20171207_models.
|
|
6284
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallAclGroupListRequest,
|
|
4979
6285
|
runtime: util_models.RuntimeOptions,
|
|
4980
|
-
) -> cloudfw_20171207_models.
|
|
6286
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallAclGroupListResponse:
|
|
6287
|
+
"""
|
|
6288
|
+
You can call the DescribeVpcFirewallAclGroupList operation to query the information about all policy groups of access control policies that are created for VPC firewalls.
|
|
6289
|
+
## Limits
|
|
6290
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6291
|
+
|
|
6292
|
+
@param request: DescribeVpcFirewallAclGroupListRequest
|
|
6293
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
6294
|
+
@return: DescribeVpcFirewallAclGroupListResponse
|
|
6295
|
+
"""
|
|
4981
6296
|
UtilClient.validate_model(request)
|
|
4982
6297
|
query = {}
|
|
4983
6298
|
if not UtilClient.is_unset(request.current_page):
|
|
4984
6299
|
query['CurrentPage'] = request.current_page
|
|
4985
|
-
if not UtilClient.is_unset(request.
|
|
4986
|
-
query['
|
|
6300
|
+
if not UtilClient.is_unset(request.firewall_configure_status):
|
|
6301
|
+
query['FirewallConfigureStatus'] = request.firewall_configure_status
|
|
4987
6302
|
if not UtilClient.is_unset(request.lang):
|
|
4988
6303
|
query['Lang'] = request.lang
|
|
4989
6304
|
if not UtilClient.is_unset(request.page_size):
|
|
4990
6305
|
query['PageSize'] = request.page_size
|
|
4991
|
-
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
4992
|
-
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
4993
6306
|
req = open_api_models.OpenApiRequest(
|
|
4994
6307
|
query=OpenApiUtilClient.query(query)
|
|
4995
6308
|
)
|
|
4996
6309
|
params = open_api_models.Params(
|
|
4997
|
-
action='
|
|
6310
|
+
action='DescribeVpcFirewallAclGroupList',
|
|
4998
6311
|
version='2017-12-07',
|
|
4999
6312
|
protocol='HTTPS',
|
|
5000
6313
|
pathname='/',
|
|
@@ -5005,32 +6318,39 @@ class Client(OpenApiClient):
|
|
|
5005
6318
|
body_type='json'
|
|
5006
6319
|
)
|
|
5007
6320
|
return TeaCore.from_map(
|
|
5008
|
-
cloudfw_20171207_models.
|
|
6321
|
+
cloudfw_20171207_models.DescribeVpcFirewallAclGroupListResponse(),
|
|
5009
6322
|
self.call_api(params, req, runtime)
|
|
5010
6323
|
)
|
|
5011
6324
|
|
|
5012
|
-
async def
|
|
6325
|
+
async def describe_vpc_firewall_acl_group_list_with_options_async(
|
|
5013
6326
|
self,
|
|
5014
|
-
request: cloudfw_20171207_models.
|
|
6327
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallAclGroupListRequest,
|
|
5015
6328
|
runtime: util_models.RuntimeOptions,
|
|
5016
|
-
) -> cloudfw_20171207_models.
|
|
6329
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallAclGroupListResponse:
|
|
6330
|
+
"""
|
|
6331
|
+
You can call the DescribeVpcFirewallAclGroupList operation to query the information about all policy groups of access control policies that are created for VPC firewalls.
|
|
6332
|
+
## Limits
|
|
6333
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6334
|
+
|
|
6335
|
+
@param request: DescribeVpcFirewallAclGroupListRequest
|
|
6336
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
6337
|
+
@return: DescribeVpcFirewallAclGroupListResponse
|
|
6338
|
+
"""
|
|
5017
6339
|
UtilClient.validate_model(request)
|
|
5018
6340
|
query = {}
|
|
5019
6341
|
if not UtilClient.is_unset(request.current_page):
|
|
5020
6342
|
query['CurrentPage'] = request.current_page
|
|
5021
|
-
if not UtilClient.is_unset(request.
|
|
5022
|
-
query['
|
|
6343
|
+
if not UtilClient.is_unset(request.firewall_configure_status):
|
|
6344
|
+
query['FirewallConfigureStatus'] = request.firewall_configure_status
|
|
5023
6345
|
if not UtilClient.is_unset(request.lang):
|
|
5024
6346
|
query['Lang'] = request.lang
|
|
5025
6347
|
if not UtilClient.is_unset(request.page_size):
|
|
5026
6348
|
query['PageSize'] = request.page_size
|
|
5027
|
-
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
5028
|
-
query['TrFirewallRoutePolicyId'] = request.tr_firewall_route_policy_id
|
|
5029
6349
|
req = open_api_models.OpenApiRequest(
|
|
5030
6350
|
query=OpenApiUtilClient.query(query)
|
|
5031
6351
|
)
|
|
5032
6352
|
params = open_api_models.Params(
|
|
5033
|
-
action='
|
|
6353
|
+
action='DescribeVpcFirewallAclGroupList',
|
|
5034
6354
|
version='2017-12-07',
|
|
5035
6355
|
protocol='HTTPS',
|
|
5036
6356
|
pathname='/',
|
|
@@ -5041,108 +6361,205 @@ class Client(OpenApiClient):
|
|
|
5041
6361
|
body_type='json'
|
|
5042
6362
|
)
|
|
5043
6363
|
return TeaCore.from_map(
|
|
5044
|
-
cloudfw_20171207_models.
|
|
6364
|
+
cloudfw_20171207_models.DescribeVpcFirewallAclGroupListResponse(),
|
|
5045
6365
|
await self.call_api_async(params, req, runtime)
|
|
5046
6366
|
)
|
|
5047
6367
|
|
|
5048
|
-
def
|
|
6368
|
+
def describe_vpc_firewall_acl_group_list(
|
|
5049
6369
|
self,
|
|
5050
|
-
request: cloudfw_20171207_models.
|
|
5051
|
-
) -> cloudfw_20171207_models.
|
|
6370
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallAclGroupListRequest,
|
|
6371
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallAclGroupListResponse:
|
|
6372
|
+
"""
|
|
6373
|
+
You can call the DescribeVpcFirewallAclGroupList operation to query the information about all policy groups of access control policies that are created for VPC firewalls.
|
|
6374
|
+
## Limits
|
|
6375
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6376
|
+
|
|
6377
|
+
@param request: DescribeVpcFirewallAclGroupListRequest
|
|
6378
|
+
@return: DescribeVpcFirewallAclGroupListResponse
|
|
6379
|
+
"""
|
|
5052
6380
|
runtime = util_models.RuntimeOptions()
|
|
5053
|
-
return self.
|
|
6381
|
+
return self.describe_vpc_firewall_acl_group_list_with_options(request, runtime)
|
|
5054
6382
|
|
|
5055
|
-
async def
|
|
6383
|
+
async def describe_vpc_firewall_acl_group_list_async(
|
|
5056
6384
|
self,
|
|
5057
|
-
request: cloudfw_20171207_models.
|
|
5058
|
-
) -> cloudfw_20171207_models.
|
|
6385
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallAclGroupListRequest,
|
|
6386
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallAclGroupListResponse:
|
|
6387
|
+
"""
|
|
6388
|
+
You can call the DescribeVpcFirewallAclGroupList operation to query the information about all policy groups of access control policies that are created for VPC firewalls.
|
|
6389
|
+
## Limits
|
|
6390
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6391
|
+
|
|
6392
|
+
@param request: DescribeVpcFirewallAclGroupListRequest
|
|
6393
|
+
@return: DescribeVpcFirewallAclGroupListResponse
|
|
6394
|
+
"""
|
|
5059
6395
|
runtime = util_models.RuntimeOptions()
|
|
5060
|
-
return await self.
|
|
6396
|
+
return await self.describe_vpc_firewall_acl_group_list_with_options_async(request, runtime)
|
|
5061
6397
|
|
|
5062
|
-
def
|
|
6398
|
+
def describe_vpc_firewall_cen_detail_with_options(
|
|
5063
6399
|
self,
|
|
5064
|
-
request: cloudfw_20171207_models.
|
|
6400
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenDetailRequest,
|
|
5065
6401
|
runtime: util_models.RuntimeOptions,
|
|
5066
|
-
) -> cloudfw_20171207_models.
|
|
6402
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenDetailResponse:
|
|
6403
|
+
"""
|
|
6404
|
+
You can call the DescribeVpcFirewallCenDetail operation to query the details about a VPC firewall. The VPC firewall protects access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6405
|
+
## Limits
|
|
6406
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6407
|
+
|
|
6408
|
+
@param request: DescribeVpcFirewallCenDetailRequest
|
|
6409
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
6410
|
+
@return: DescribeVpcFirewallCenDetailResponse
|
|
6411
|
+
"""
|
|
5067
6412
|
UtilClient.validate_model(request)
|
|
5068
|
-
query =
|
|
6413
|
+
query = {}
|
|
6414
|
+
if not UtilClient.is_unset(request.lang):
|
|
6415
|
+
query['Lang'] = request.lang
|
|
6416
|
+
if not UtilClient.is_unset(request.lang):
|
|
6417
|
+
query['Lang'] = request.lang
|
|
6418
|
+
if not UtilClient.is_unset(request.network_instance_id):
|
|
6419
|
+
query['NetworkInstanceId'] = request.network_instance_id
|
|
6420
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
6421
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5069
6422
|
req = open_api_models.OpenApiRequest(
|
|
5070
6423
|
query=OpenApiUtilClient.query(query)
|
|
5071
6424
|
)
|
|
5072
6425
|
params = open_api_models.Params(
|
|
5073
|
-
action='
|
|
6426
|
+
action='DescribeVpcFirewallCenDetail',
|
|
5074
6427
|
version='2017-12-07',
|
|
5075
6428
|
protocol='HTTPS',
|
|
5076
6429
|
pathname='/',
|
|
5077
|
-
method='
|
|
6430
|
+
method='POST',
|
|
5078
6431
|
auth_type='AK',
|
|
5079
6432
|
style='RPC',
|
|
5080
6433
|
req_body_type='formData',
|
|
5081
6434
|
body_type='json'
|
|
5082
6435
|
)
|
|
5083
6436
|
return TeaCore.from_map(
|
|
5084
|
-
cloudfw_20171207_models.
|
|
6437
|
+
cloudfw_20171207_models.DescribeVpcFirewallCenDetailResponse(),
|
|
5085
6438
|
self.call_api(params, req, runtime)
|
|
5086
6439
|
)
|
|
5087
6440
|
|
|
5088
|
-
async def
|
|
6441
|
+
async def describe_vpc_firewall_cen_detail_with_options_async(
|
|
5089
6442
|
self,
|
|
5090
|
-
request: cloudfw_20171207_models.
|
|
6443
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenDetailRequest,
|
|
5091
6444
|
runtime: util_models.RuntimeOptions,
|
|
5092
|
-
) -> cloudfw_20171207_models.
|
|
6445
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenDetailResponse:
|
|
6446
|
+
"""
|
|
6447
|
+
You can call the DescribeVpcFirewallCenDetail operation to query the details about a VPC firewall. The VPC firewall protects access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6448
|
+
## Limits
|
|
6449
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6450
|
+
|
|
6451
|
+
@param request: DescribeVpcFirewallCenDetailRequest
|
|
6452
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
6453
|
+
@return: DescribeVpcFirewallCenDetailResponse
|
|
6454
|
+
"""
|
|
5093
6455
|
UtilClient.validate_model(request)
|
|
5094
|
-
query =
|
|
6456
|
+
query = {}
|
|
6457
|
+
if not UtilClient.is_unset(request.lang):
|
|
6458
|
+
query['Lang'] = request.lang
|
|
6459
|
+
if not UtilClient.is_unset(request.lang):
|
|
6460
|
+
query['Lang'] = request.lang
|
|
6461
|
+
if not UtilClient.is_unset(request.network_instance_id):
|
|
6462
|
+
query['NetworkInstanceId'] = request.network_instance_id
|
|
6463
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
6464
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5095
6465
|
req = open_api_models.OpenApiRequest(
|
|
5096
6466
|
query=OpenApiUtilClient.query(query)
|
|
5097
6467
|
)
|
|
5098
6468
|
params = open_api_models.Params(
|
|
5099
|
-
action='
|
|
6469
|
+
action='DescribeVpcFirewallCenDetail',
|
|
5100
6470
|
version='2017-12-07',
|
|
5101
6471
|
protocol='HTTPS',
|
|
5102
6472
|
pathname='/',
|
|
5103
|
-
method='
|
|
6473
|
+
method='POST',
|
|
5104
6474
|
auth_type='AK',
|
|
5105
6475
|
style='RPC',
|
|
5106
6476
|
req_body_type='formData',
|
|
5107
6477
|
body_type='json'
|
|
5108
6478
|
)
|
|
5109
6479
|
return TeaCore.from_map(
|
|
5110
|
-
cloudfw_20171207_models.
|
|
6480
|
+
cloudfw_20171207_models.DescribeVpcFirewallCenDetailResponse(),
|
|
5111
6481
|
await self.call_api_async(params, req, runtime)
|
|
5112
6482
|
)
|
|
5113
6483
|
|
|
5114
|
-
def
|
|
6484
|
+
def describe_vpc_firewall_cen_detail(
|
|
5115
6485
|
self,
|
|
5116
|
-
request: cloudfw_20171207_models.
|
|
5117
|
-
) -> cloudfw_20171207_models.
|
|
6486
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenDetailRequest,
|
|
6487
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenDetailResponse:
|
|
6488
|
+
"""
|
|
6489
|
+
You can call the DescribeVpcFirewallCenDetail operation to query the details about a VPC firewall. The VPC firewall protects access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6490
|
+
## Limits
|
|
6491
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6492
|
+
|
|
6493
|
+
@param request: DescribeVpcFirewallCenDetailRequest
|
|
6494
|
+
@return: DescribeVpcFirewallCenDetailResponse
|
|
6495
|
+
"""
|
|
5118
6496
|
runtime = util_models.RuntimeOptions()
|
|
5119
|
-
return self.
|
|
6497
|
+
return self.describe_vpc_firewall_cen_detail_with_options(request, runtime)
|
|
5120
6498
|
|
|
5121
|
-
async def
|
|
6499
|
+
async def describe_vpc_firewall_cen_detail_async(
|
|
5122
6500
|
self,
|
|
5123
|
-
request: cloudfw_20171207_models.
|
|
5124
|
-
) -> cloudfw_20171207_models.
|
|
6501
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenDetailRequest,
|
|
6502
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenDetailResponse:
|
|
6503
|
+
"""
|
|
6504
|
+
You can call the DescribeVpcFirewallCenDetail operation to query the details about a VPC firewall. The VPC firewall protects access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6505
|
+
## Limits
|
|
6506
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6507
|
+
|
|
6508
|
+
@param request: DescribeVpcFirewallCenDetailRequest
|
|
6509
|
+
@return: DescribeVpcFirewallCenDetailResponse
|
|
6510
|
+
"""
|
|
5125
6511
|
runtime = util_models.RuntimeOptions()
|
|
5126
|
-
return await self.
|
|
6512
|
+
return await self.describe_vpc_firewall_cen_detail_with_options_async(request, runtime)
|
|
5127
6513
|
|
|
5128
|
-
def
|
|
6514
|
+
def describe_vpc_firewall_cen_list_with_options(
|
|
5129
6515
|
self,
|
|
5130
|
-
request: cloudfw_20171207_models.
|
|
6516
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenListRequest,
|
|
5131
6517
|
runtime: util_models.RuntimeOptions,
|
|
5132
|
-
) -> cloudfw_20171207_models.
|
|
6518
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenListResponse:
|
|
6519
|
+
"""
|
|
6520
|
+
You can call the DescribeVpcFirewallCenList operation to query VPC firewalls. A VPC firewall protects mutual access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6521
|
+
## Limits
|
|
6522
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6523
|
+
|
|
6524
|
+
@param request: DescribeVpcFirewallCenListRequest
|
|
6525
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
6526
|
+
@return: DescribeVpcFirewallCenListResponse
|
|
6527
|
+
"""
|
|
5133
6528
|
UtilClient.validate_model(request)
|
|
5134
6529
|
query = {}
|
|
6530
|
+
if not UtilClient.is_unset(request.cen_id):
|
|
6531
|
+
query['CenId'] = request.cen_id
|
|
6532
|
+
if not UtilClient.is_unset(request.current_page):
|
|
6533
|
+
query['CurrentPage'] = request.current_page
|
|
6534
|
+
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
6535
|
+
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
5135
6536
|
if not UtilClient.is_unset(request.lang):
|
|
5136
6537
|
query['Lang'] = request.lang
|
|
5137
6538
|
if not UtilClient.is_unset(request.lang):
|
|
5138
6539
|
query['Lang'] = request.lang
|
|
5139
|
-
if not UtilClient.is_unset(request.
|
|
5140
|
-
query['
|
|
6540
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
6541
|
+
query['MemberUid'] = request.member_uid
|
|
6542
|
+
if not UtilClient.is_unset(request.network_instance_id):
|
|
6543
|
+
query['NetworkInstanceId'] = request.network_instance_id
|
|
6544
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
6545
|
+
query['OwnerId'] = request.owner_id
|
|
6546
|
+
if not UtilClient.is_unset(request.page_size):
|
|
6547
|
+
query['PageSize'] = request.page_size
|
|
6548
|
+
if not UtilClient.is_unset(request.region_no):
|
|
6549
|
+
query['RegionNo'] = request.region_no
|
|
6550
|
+
if not UtilClient.is_unset(request.route_mode):
|
|
6551
|
+
query['RouteMode'] = request.route_mode
|
|
6552
|
+
if not UtilClient.is_unset(request.transit_router_type):
|
|
6553
|
+
query['TransitRouterType'] = request.transit_router_type
|
|
6554
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
6555
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
6556
|
+
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
6557
|
+
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
5141
6558
|
req = open_api_models.OpenApiRequest(
|
|
5142
6559
|
query=OpenApiUtilClient.query(query)
|
|
5143
6560
|
)
|
|
5144
6561
|
params = open_api_models.Params(
|
|
5145
|
-
action='
|
|
6562
|
+
action='DescribeVpcFirewallCenList',
|
|
5146
6563
|
version='2017-12-07',
|
|
5147
6564
|
protocol='HTTPS',
|
|
5148
6565
|
pathname='/',
|
|
@@ -5153,28 +6570,59 @@ class Client(OpenApiClient):
|
|
|
5153
6570
|
body_type='json'
|
|
5154
6571
|
)
|
|
5155
6572
|
return TeaCore.from_map(
|
|
5156
|
-
cloudfw_20171207_models.
|
|
6573
|
+
cloudfw_20171207_models.DescribeVpcFirewallCenListResponse(),
|
|
5157
6574
|
self.call_api(params, req, runtime)
|
|
5158
6575
|
)
|
|
5159
6576
|
|
|
5160
|
-
async def
|
|
6577
|
+
async def describe_vpc_firewall_cen_list_with_options_async(
|
|
5161
6578
|
self,
|
|
5162
|
-
request: cloudfw_20171207_models.
|
|
6579
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenListRequest,
|
|
5163
6580
|
runtime: util_models.RuntimeOptions,
|
|
5164
|
-
) -> cloudfw_20171207_models.
|
|
6581
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenListResponse:
|
|
6582
|
+
"""
|
|
6583
|
+
You can call the DescribeVpcFirewallCenList operation to query VPC firewalls. A VPC firewall protects mutual access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6584
|
+
## Limits
|
|
6585
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6586
|
+
|
|
6587
|
+
@param request: DescribeVpcFirewallCenListRequest
|
|
6588
|
+
@param runtime: runtime options for this request RuntimeOptions
|
|
6589
|
+
@return: DescribeVpcFirewallCenListResponse
|
|
6590
|
+
"""
|
|
5165
6591
|
UtilClient.validate_model(request)
|
|
5166
6592
|
query = {}
|
|
6593
|
+
if not UtilClient.is_unset(request.cen_id):
|
|
6594
|
+
query['CenId'] = request.cen_id
|
|
6595
|
+
if not UtilClient.is_unset(request.current_page):
|
|
6596
|
+
query['CurrentPage'] = request.current_page
|
|
6597
|
+
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
6598
|
+
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
5167
6599
|
if not UtilClient.is_unset(request.lang):
|
|
5168
6600
|
query['Lang'] = request.lang
|
|
5169
6601
|
if not UtilClient.is_unset(request.lang):
|
|
5170
6602
|
query['Lang'] = request.lang
|
|
5171
|
-
if not UtilClient.is_unset(request.
|
|
5172
|
-
query['
|
|
6603
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
6604
|
+
query['MemberUid'] = request.member_uid
|
|
6605
|
+
if not UtilClient.is_unset(request.network_instance_id):
|
|
6606
|
+
query['NetworkInstanceId'] = request.network_instance_id
|
|
6607
|
+
if not UtilClient.is_unset(request.owner_id):
|
|
6608
|
+
query['OwnerId'] = request.owner_id
|
|
6609
|
+
if not UtilClient.is_unset(request.page_size):
|
|
6610
|
+
query['PageSize'] = request.page_size
|
|
6611
|
+
if not UtilClient.is_unset(request.region_no):
|
|
6612
|
+
query['RegionNo'] = request.region_no
|
|
6613
|
+
if not UtilClient.is_unset(request.route_mode):
|
|
6614
|
+
query['RouteMode'] = request.route_mode
|
|
6615
|
+
if not UtilClient.is_unset(request.transit_router_type):
|
|
6616
|
+
query['TransitRouterType'] = request.transit_router_type
|
|
6617
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
6618
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
6619
|
+
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
6620
|
+
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
5173
6621
|
req = open_api_models.OpenApiRequest(
|
|
5174
6622
|
query=OpenApiUtilClient.query(query)
|
|
5175
6623
|
)
|
|
5176
6624
|
params = open_api_models.Params(
|
|
5177
|
-
action='
|
|
6625
|
+
action='DescribeVpcFirewallCenList',
|
|
5178
6626
|
version='2017-12-07',
|
|
5179
6627
|
protocol='HTTPS',
|
|
5180
6628
|
pathname='/',
|
|
@@ -5185,53 +6633,87 @@ class Client(OpenApiClient):
|
|
|
5185
6633
|
body_type='json'
|
|
5186
6634
|
)
|
|
5187
6635
|
return TeaCore.from_map(
|
|
5188
|
-
cloudfw_20171207_models.
|
|
6636
|
+
cloudfw_20171207_models.DescribeVpcFirewallCenListResponse(),
|
|
5189
6637
|
await self.call_api_async(params, req, runtime)
|
|
5190
6638
|
)
|
|
5191
6639
|
|
|
5192
|
-
def
|
|
6640
|
+
def describe_vpc_firewall_cen_list(
|
|
5193
6641
|
self,
|
|
5194
|
-
request: cloudfw_20171207_models.
|
|
5195
|
-
) -> cloudfw_20171207_models.
|
|
6642
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenListRequest,
|
|
6643
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenListResponse:
|
|
6644
|
+
"""
|
|
6645
|
+
You can call the DescribeVpcFirewallCenList operation to query VPC firewalls. A VPC firewall protects mutual access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6646
|
+
## Limits
|
|
6647
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6648
|
+
|
|
6649
|
+
@param request: DescribeVpcFirewallCenListRequest
|
|
6650
|
+
@return: DescribeVpcFirewallCenListResponse
|
|
6651
|
+
"""
|
|
5196
6652
|
runtime = util_models.RuntimeOptions()
|
|
5197
|
-
return self.
|
|
6653
|
+
return self.describe_vpc_firewall_cen_list_with_options(request, runtime)
|
|
5198
6654
|
|
|
5199
|
-
async def
|
|
6655
|
+
async def describe_vpc_firewall_cen_list_async(
|
|
5200
6656
|
self,
|
|
5201
|
-
request: cloudfw_20171207_models.
|
|
5202
|
-
) -> cloudfw_20171207_models.
|
|
6657
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallCenListRequest,
|
|
6658
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallCenListResponse:
|
|
6659
|
+
"""
|
|
6660
|
+
You can call the DescribeVpcFirewallCenList operation to query VPC firewalls. A VPC firewall protects mutual access traffic between a specified VPC and a network instance that is attached to a CEN instance. The network instance can be a VPC, a virtual border router (VBR), or a Cloud Connect Network (CCN) instance.
|
|
6661
|
+
## Limits
|
|
6662
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6663
|
+
|
|
6664
|
+
@param request: DescribeVpcFirewallCenListRequest
|
|
6665
|
+
@return: DescribeVpcFirewallCenListResponse
|
|
6666
|
+
"""
|
|
5203
6667
|
runtime = util_models.RuntimeOptions()
|
|
5204
|
-
return await self.
|
|
6668
|
+
return await self.describe_vpc_firewall_cen_list_with_options_async(request, runtime)
|
|
5205
6669
|
|
|
5206
|
-
def
|
|
6670
|
+
def describe_vpc_firewall_control_policy_with_options(
|
|
5207
6671
|
self,
|
|
5208
|
-
request: cloudfw_20171207_models.
|
|
6672
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallControlPolicyRequest,
|
|
5209
6673
|
runtime: util_models.RuntimeOptions,
|
|
5210
|
-
) -> cloudfw_20171207_models.
|
|
6674
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallControlPolicyResponse:
|
|
5211
6675
|
"""
|
|
5212
|
-
You can call the
|
|
6676
|
+
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5213
6677
|
## Limits
|
|
5214
6678
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5215
6679
|
|
|
5216
|
-
@param request:
|
|
6680
|
+
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
5217
6681
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5218
|
-
@return:
|
|
6682
|
+
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5219
6683
|
"""
|
|
5220
6684
|
UtilClient.validate_model(request)
|
|
5221
6685
|
query = {}
|
|
6686
|
+
if not UtilClient.is_unset(request.acl_action):
|
|
6687
|
+
query['AclAction'] = request.acl_action
|
|
6688
|
+
if not UtilClient.is_unset(request.acl_uuid):
|
|
6689
|
+
query['AclUuid'] = request.acl_uuid
|
|
5222
6690
|
if not UtilClient.is_unset(request.current_page):
|
|
5223
6691
|
query['CurrentPage'] = request.current_page
|
|
5224
|
-
if not UtilClient.is_unset(request.
|
|
5225
|
-
query['
|
|
6692
|
+
if not UtilClient.is_unset(request.description):
|
|
6693
|
+
query['Description'] = request.description
|
|
6694
|
+
if not UtilClient.is_unset(request.destination):
|
|
6695
|
+
query['Destination'] = request.destination
|
|
5226
6696
|
if not UtilClient.is_unset(request.lang):
|
|
5227
6697
|
query['Lang'] = request.lang
|
|
6698
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
6699
|
+
query['MemberUid'] = request.member_uid
|
|
5228
6700
|
if not UtilClient.is_unset(request.page_size):
|
|
5229
6701
|
query['PageSize'] = request.page_size
|
|
6702
|
+
if not UtilClient.is_unset(request.proto):
|
|
6703
|
+
query['Proto'] = request.proto
|
|
6704
|
+
if not UtilClient.is_unset(request.release):
|
|
6705
|
+
query['Release'] = request.release
|
|
6706
|
+
if not UtilClient.is_unset(request.repeat_type):
|
|
6707
|
+
query['RepeatType'] = request.repeat_type
|
|
6708
|
+
if not UtilClient.is_unset(request.source):
|
|
6709
|
+
query['Source'] = request.source
|
|
6710
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
6711
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5230
6712
|
req = open_api_models.OpenApiRequest(
|
|
5231
6713
|
query=OpenApiUtilClient.query(query)
|
|
5232
6714
|
)
|
|
5233
6715
|
params = open_api_models.Params(
|
|
5234
|
-
action='
|
|
6716
|
+
action='DescribeVpcFirewallControlPolicy',
|
|
5235
6717
|
version='2017-12-07',
|
|
5236
6718
|
protocol='HTTPS',
|
|
5237
6719
|
pathname='/',
|
|
@@ -5242,39 +6724,57 @@ class Client(OpenApiClient):
|
|
|
5242
6724
|
body_type='json'
|
|
5243
6725
|
)
|
|
5244
6726
|
return TeaCore.from_map(
|
|
5245
|
-
cloudfw_20171207_models.
|
|
6727
|
+
cloudfw_20171207_models.DescribeVpcFirewallControlPolicyResponse(),
|
|
5246
6728
|
self.call_api(params, req, runtime)
|
|
5247
6729
|
)
|
|
5248
6730
|
|
|
5249
|
-
async def
|
|
6731
|
+
async def describe_vpc_firewall_control_policy_with_options_async(
|
|
5250
6732
|
self,
|
|
5251
|
-
request: cloudfw_20171207_models.
|
|
6733
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallControlPolicyRequest,
|
|
5252
6734
|
runtime: util_models.RuntimeOptions,
|
|
5253
|
-
) -> cloudfw_20171207_models.
|
|
6735
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallControlPolicyResponse:
|
|
5254
6736
|
"""
|
|
5255
|
-
You can call the
|
|
6737
|
+
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5256
6738
|
## Limits
|
|
5257
6739
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5258
6740
|
|
|
5259
|
-
@param request:
|
|
6741
|
+
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
5260
6742
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5261
|
-
@return:
|
|
6743
|
+
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5262
6744
|
"""
|
|
5263
6745
|
UtilClient.validate_model(request)
|
|
5264
6746
|
query = {}
|
|
6747
|
+
if not UtilClient.is_unset(request.acl_action):
|
|
6748
|
+
query['AclAction'] = request.acl_action
|
|
6749
|
+
if not UtilClient.is_unset(request.acl_uuid):
|
|
6750
|
+
query['AclUuid'] = request.acl_uuid
|
|
5265
6751
|
if not UtilClient.is_unset(request.current_page):
|
|
5266
6752
|
query['CurrentPage'] = request.current_page
|
|
5267
|
-
if not UtilClient.is_unset(request.
|
|
5268
|
-
query['
|
|
6753
|
+
if not UtilClient.is_unset(request.description):
|
|
6754
|
+
query['Description'] = request.description
|
|
6755
|
+
if not UtilClient.is_unset(request.destination):
|
|
6756
|
+
query['Destination'] = request.destination
|
|
5269
6757
|
if not UtilClient.is_unset(request.lang):
|
|
5270
6758
|
query['Lang'] = request.lang
|
|
6759
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
6760
|
+
query['MemberUid'] = request.member_uid
|
|
5271
6761
|
if not UtilClient.is_unset(request.page_size):
|
|
5272
6762
|
query['PageSize'] = request.page_size
|
|
6763
|
+
if not UtilClient.is_unset(request.proto):
|
|
6764
|
+
query['Proto'] = request.proto
|
|
6765
|
+
if not UtilClient.is_unset(request.release):
|
|
6766
|
+
query['Release'] = request.release
|
|
6767
|
+
if not UtilClient.is_unset(request.repeat_type):
|
|
6768
|
+
query['RepeatType'] = request.repeat_type
|
|
6769
|
+
if not UtilClient.is_unset(request.source):
|
|
6770
|
+
query['Source'] = request.source
|
|
6771
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
6772
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5273
6773
|
req = open_api_models.OpenApiRequest(
|
|
5274
6774
|
query=OpenApiUtilClient.query(query)
|
|
5275
6775
|
)
|
|
5276
6776
|
params = open_api_models.Params(
|
|
5277
|
-
action='
|
|
6777
|
+
action='DescribeVpcFirewallControlPolicy',
|
|
5278
6778
|
version='2017-12-07',
|
|
5279
6779
|
protocol='HTTPS',
|
|
5280
6780
|
pathname='/',
|
|
@@ -5285,69 +6785,65 @@ class Client(OpenApiClient):
|
|
|
5285
6785
|
body_type='json'
|
|
5286
6786
|
)
|
|
5287
6787
|
return TeaCore.from_map(
|
|
5288
|
-
cloudfw_20171207_models.
|
|
6788
|
+
cloudfw_20171207_models.DescribeVpcFirewallControlPolicyResponse(),
|
|
5289
6789
|
await self.call_api_async(params, req, runtime)
|
|
5290
6790
|
)
|
|
5291
6791
|
|
|
5292
|
-
def
|
|
6792
|
+
def describe_vpc_firewall_control_policy(
|
|
5293
6793
|
self,
|
|
5294
|
-
request: cloudfw_20171207_models.
|
|
5295
|
-
) -> cloudfw_20171207_models.
|
|
6794
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallControlPolicyRequest,
|
|
6795
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallControlPolicyResponse:
|
|
5296
6796
|
"""
|
|
5297
|
-
You can call the
|
|
6797
|
+
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5298
6798
|
## Limits
|
|
5299
6799
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5300
6800
|
|
|
5301
|
-
@param request:
|
|
5302
|
-
@return:
|
|
6801
|
+
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
6802
|
+
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5303
6803
|
"""
|
|
5304
6804
|
runtime = util_models.RuntimeOptions()
|
|
5305
|
-
return self.
|
|
6805
|
+
return self.describe_vpc_firewall_control_policy_with_options(request, runtime)
|
|
5306
6806
|
|
|
5307
|
-
async def
|
|
6807
|
+
async def describe_vpc_firewall_control_policy_async(
|
|
5308
6808
|
self,
|
|
5309
|
-
request: cloudfw_20171207_models.
|
|
5310
|
-
) -> cloudfw_20171207_models.
|
|
6809
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallControlPolicyRequest,
|
|
6810
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallControlPolicyResponse:
|
|
5311
6811
|
"""
|
|
5312
|
-
You can call the
|
|
6812
|
+
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5313
6813
|
## Limits
|
|
5314
6814
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5315
6815
|
|
|
5316
|
-
@param request:
|
|
5317
|
-
@return:
|
|
6816
|
+
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
6817
|
+
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5318
6818
|
"""
|
|
5319
6819
|
runtime = util_models.RuntimeOptions()
|
|
5320
|
-
return await self.
|
|
6820
|
+
return await self.describe_vpc_firewall_control_policy_with_options_async(request, runtime)
|
|
5321
6821
|
|
|
5322
|
-
def
|
|
6822
|
+
def describe_vpc_firewall_default_ipsconfig_with_options(
|
|
5323
6823
|
self,
|
|
5324
|
-
request: cloudfw_20171207_models.
|
|
6824
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigRequest,
|
|
5325
6825
|
runtime: util_models.RuntimeOptions,
|
|
5326
|
-
) -> cloudfw_20171207_models.
|
|
6826
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigResponse:
|
|
5327
6827
|
"""
|
|
5328
|
-
You can call the
|
|
6828
|
+
You can call the DescribeVpcFirewallDefaultIPSConfig operation to query the intrusion prevention configurations of a VPC firewall.
|
|
5329
6829
|
## Limits
|
|
5330
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6830
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5331
6831
|
|
|
5332
|
-
@param request:
|
|
6832
|
+
@param request: DescribeVpcFirewallDefaultIPSConfigRequest
|
|
5333
6833
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5334
|
-
@return:
|
|
6834
|
+
@return: DescribeVpcFirewallDefaultIPSConfigResponse
|
|
5335
6835
|
"""
|
|
5336
6836
|
UtilClient.validate_model(request)
|
|
5337
6837
|
query = {}
|
|
5338
|
-
if not UtilClient.is_unset(request.
|
|
5339
|
-
query['
|
|
5340
|
-
if not UtilClient.is_unset(request.lang):
|
|
5341
|
-
query['Lang'] = request.lang
|
|
5342
|
-
if not UtilClient.is_unset(request.network_instance_id):
|
|
5343
|
-
query['NetworkInstanceId'] = request.network_instance_id
|
|
6838
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
6839
|
+
query['MemberUid'] = request.member_uid
|
|
5344
6840
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5345
6841
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5346
6842
|
req = open_api_models.OpenApiRequest(
|
|
5347
6843
|
query=OpenApiUtilClient.query(query)
|
|
5348
6844
|
)
|
|
5349
6845
|
params = open_api_models.Params(
|
|
5350
|
-
action='
|
|
6846
|
+
action='DescribeVpcFirewallDefaultIPSConfig',
|
|
5351
6847
|
version='2017-12-07',
|
|
5352
6848
|
protocol='HTTPS',
|
|
5353
6849
|
pathname='/',
|
|
@@ -5358,39 +6854,35 @@ class Client(OpenApiClient):
|
|
|
5358
6854
|
body_type='json'
|
|
5359
6855
|
)
|
|
5360
6856
|
return TeaCore.from_map(
|
|
5361
|
-
cloudfw_20171207_models.
|
|
6857
|
+
cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigResponse(),
|
|
5362
6858
|
self.call_api(params, req, runtime)
|
|
5363
6859
|
)
|
|
5364
6860
|
|
|
5365
|
-
async def
|
|
6861
|
+
async def describe_vpc_firewall_default_ipsconfig_with_options_async(
|
|
5366
6862
|
self,
|
|
5367
|
-
request: cloudfw_20171207_models.
|
|
6863
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigRequest,
|
|
5368
6864
|
runtime: util_models.RuntimeOptions,
|
|
5369
|
-
) -> cloudfw_20171207_models.
|
|
6865
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigResponse:
|
|
5370
6866
|
"""
|
|
5371
|
-
You can call the
|
|
6867
|
+
You can call the DescribeVpcFirewallDefaultIPSConfig operation to query the intrusion prevention configurations of a VPC firewall.
|
|
5372
6868
|
## Limits
|
|
5373
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6869
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5374
6870
|
|
|
5375
|
-
@param request:
|
|
6871
|
+
@param request: DescribeVpcFirewallDefaultIPSConfigRequest
|
|
5376
6872
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5377
|
-
@return:
|
|
6873
|
+
@return: DescribeVpcFirewallDefaultIPSConfigResponse
|
|
5378
6874
|
"""
|
|
5379
6875
|
UtilClient.validate_model(request)
|
|
5380
6876
|
query = {}
|
|
5381
|
-
if not UtilClient.is_unset(request.
|
|
5382
|
-
query['
|
|
5383
|
-
if not UtilClient.is_unset(request.lang):
|
|
5384
|
-
query['Lang'] = request.lang
|
|
5385
|
-
if not UtilClient.is_unset(request.network_instance_id):
|
|
5386
|
-
query['NetworkInstanceId'] = request.network_instance_id
|
|
6877
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
6878
|
+
query['MemberUid'] = request.member_uid
|
|
5387
6879
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5388
6880
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5389
6881
|
req = open_api_models.OpenApiRequest(
|
|
5390
6882
|
query=OpenApiUtilClient.query(query)
|
|
5391
6883
|
)
|
|
5392
6884
|
params = open_api_models.Params(
|
|
5393
|
-
action='
|
|
6885
|
+
action='DescribeVpcFirewallDefaultIPSConfig',
|
|
5394
6886
|
version='2017-12-07',
|
|
5395
6887
|
protocol='HTTPS',
|
|
5396
6888
|
pathname='/',
|
|
@@ -5401,89 +6893,72 @@ class Client(OpenApiClient):
|
|
|
5401
6893
|
body_type='json'
|
|
5402
6894
|
)
|
|
5403
6895
|
return TeaCore.from_map(
|
|
5404
|
-
cloudfw_20171207_models.
|
|
6896
|
+
cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigResponse(),
|
|
5405
6897
|
await self.call_api_async(params, req, runtime)
|
|
5406
6898
|
)
|
|
5407
6899
|
|
|
5408
|
-
def
|
|
6900
|
+
def describe_vpc_firewall_default_ipsconfig(
|
|
5409
6901
|
self,
|
|
5410
|
-
request: cloudfw_20171207_models.
|
|
5411
|
-
) -> cloudfw_20171207_models.
|
|
6902
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigRequest,
|
|
6903
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigResponse:
|
|
5412
6904
|
"""
|
|
5413
|
-
You can call the
|
|
6905
|
+
You can call the DescribeVpcFirewallDefaultIPSConfig operation to query the intrusion prevention configurations of a VPC firewall.
|
|
5414
6906
|
## Limits
|
|
5415
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6907
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5416
6908
|
|
|
5417
|
-
@param request:
|
|
5418
|
-
@return:
|
|
6909
|
+
@param request: DescribeVpcFirewallDefaultIPSConfigRequest
|
|
6910
|
+
@return: DescribeVpcFirewallDefaultIPSConfigResponse
|
|
5419
6911
|
"""
|
|
5420
6912
|
runtime = util_models.RuntimeOptions()
|
|
5421
|
-
return self.
|
|
6913
|
+
return self.describe_vpc_firewall_default_ipsconfig_with_options(request, runtime)
|
|
5422
6914
|
|
|
5423
|
-
async def
|
|
6915
|
+
async def describe_vpc_firewall_default_ipsconfig_async(
|
|
5424
6916
|
self,
|
|
5425
|
-
request: cloudfw_20171207_models.
|
|
5426
|
-
) -> cloudfw_20171207_models.
|
|
6917
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigRequest,
|
|
6918
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDefaultIPSConfigResponse:
|
|
5427
6919
|
"""
|
|
5428
|
-
You can call the
|
|
6920
|
+
You can call the DescribeVpcFirewallDefaultIPSConfig operation to query the intrusion prevention configurations of a VPC firewall.
|
|
5429
6921
|
## Limits
|
|
5430
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6922
|
+
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5431
6923
|
|
|
5432
|
-
@param request:
|
|
5433
|
-
@return:
|
|
6924
|
+
@param request: DescribeVpcFirewallDefaultIPSConfigRequest
|
|
6925
|
+
@return: DescribeVpcFirewallDefaultIPSConfigResponse
|
|
5434
6926
|
"""
|
|
5435
6927
|
runtime = util_models.RuntimeOptions()
|
|
5436
|
-
return await self.
|
|
6928
|
+
return await self.describe_vpc_firewall_default_ipsconfig_with_options_async(request, runtime)
|
|
5437
6929
|
|
|
5438
|
-
def
|
|
6930
|
+
def describe_vpc_firewall_detail_with_options(
|
|
5439
6931
|
self,
|
|
5440
|
-
request: cloudfw_20171207_models.
|
|
6932
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDetailRequest,
|
|
5441
6933
|
runtime: util_models.RuntimeOptions,
|
|
5442
|
-
) -> cloudfw_20171207_models.
|
|
6934
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDetailResponse:
|
|
5443
6935
|
"""
|
|
5444
|
-
You can call the
|
|
6936
|
+
You can call the DescribeVpcFirewallDetail operation to query the details about a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
6937
|
+
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
5445
6938
|
## Limits
|
|
5446
6939
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5447
6940
|
|
|
5448
|
-
@param request:
|
|
6941
|
+
@param request: DescribeVpcFirewallDetailRequest
|
|
5449
6942
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5450
|
-
@return:
|
|
6943
|
+
@return: DescribeVpcFirewallDetailResponse
|
|
5451
6944
|
"""
|
|
5452
6945
|
UtilClient.validate_model(request)
|
|
5453
6946
|
query = {}
|
|
5454
|
-
if not UtilClient.is_unset(request.cen_id):
|
|
5455
|
-
query['CenId'] = request.cen_id
|
|
5456
|
-
if not UtilClient.is_unset(request.current_page):
|
|
5457
|
-
query['CurrentPage'] = request.current_page
|
|
5458
|
-
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
5459
|
-
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
5460
6947
|
if not UtilClient.is_unset(request.lang):
|
|
5461
6948
|
query['Lang'] = request.lang
|
|
5462
6949
|
if not UtilClient.is_unset(request.lang):
|
|
5463
6950
|
query['Lang'] = request.lang
|
|
5464
|
-
if not UtilClient.is_unset(request.
|
|
5465
|
-
query['
|
|
5466
|
-
if not UtilClient.is_unset(request.
|
|
5467
|
-
query['
|
|
5468
|
-
if not UtilClient.is_unset(request.owner_id):
|
|
5469
|
-
query['OwnerId'] = request.owner_id
|
|
5470
|
-
if not UtilClient.is_unset(request.page_size):
|
|
5471
|
-
query['PageSize'] = request.page_size
|
|
5472
|
-
if not UtilClient.is_unset(request.region_no):
|
|
5473
|
-
query['RegionNo'] = request.region_no
|
|
5474
|
-
if not UtilClient.is_unset(request.route_mode):
|
|
5475
|
-
query['RouteMode'] = request.route_mode
|
|
5476
|
-
if not UtilClient.is_unset(request.transit_router_type):
|
|
5477
|
-
query['TransitRouterType'] = request.transit_router_type
|
|
6951
|
+
if not UtilClient.is_unset(request.local_vpc_id):
|
|
6952
|
+
query['LocalVpcId'] = request.local_vpc_id
|
|
6953
|
+
if not UtilClient.is_unset(request.peer_vpc_id):
|
|
6954
|
+
query['PeerVpcId'] = request.peer_vpc_id
|
|
5478
6955
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5479
6956
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5480
|
-
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
5481
|
-
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
5482
6957
|
req = open_api_models.OpenApiRequest(
|
|
5483
6958
|
query=OpenApiUtilClient.query(query)
|
|
5484
6959
|
)
|
|
5485
6960
|
params = open_api_models.Params(
|
|
5486
|
-
action='
|
|
6961
|
+
action='DescribeVpcFirewallDetail',
|
|
5487
6962
|
version='2017-12-07',
|
|
5488
6963
|
protocol='HTTPS',
|
|
5489
6964
|
pathname='/',
|
|
@@ -5494,59 +6969,42 @@ class Client(OpenApiClient):
|
|
|
5494
6969
|
body_type='json'
|
|
5495
6970
|
)
|
|
5496
6971
|
return TeaCore.from_map(
|
|
5497
|
-
cloudfw_20171207_models.
|
|
6972
|
+
cloudfw_20171207_models.DescribeVpcFirewallDetailResponse(),
|
|
5498
6973
|
self.call_api(params, req, runtime)
|
|
5499
6974
|
)
|
|
5500
6975
|
|
|
5501
|
-
async def
|
|
6976
|
+
async def describe_vpc_firewall_detail_with_options_async(
|
|
5502
6977
|
self,
|
|
5503
|
-
request: cloudfw_20171207_models.
|
|
6978
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDetailRequest,
|
|
5504
6979
|
runtime: util_models.RuntimeOptions,
|
|
5505
|
-
) -> cloudfw_20171207_models.
|
|
6980
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDetailResponse:
|
|
5506
6981
|
"""
|
|
5507
|
-
You can call the
|
|
6982
|
+
You can call the DescribeVpcFirewallDetail operation to query the details about a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
6983
|
+
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
5508
6984
|
## Limits
|
|
5509
6985
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5510
6986
|
|
|
5511
|
-
@param request:
|
|
6987
|
+
@param request: DescribeVpcFirewallDetailRequest
|
|
5512
6988
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5513
|
-
@return:
|
|
6989
|
+
@return: DescribeVpcFirewallDetailResponse
|
|
5514
6990
|
"""
|
|
5515
6991
|
UtilClient.validate_model(request)
|
|
5516
6992
|
query = {}
|
|
5517
|
-
if not UtilClient.is_unset(request.cen_id):
|
|
5518
|
-
query['CenId'] = request.cen_id
|
|
5519
|
-
if not UtilClient.is_unset(request.current_page):
|
|
5520
|
-
query['CurrentPage'] = request.current_page
|
|
5521
|
-
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
5522
|
-
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
5523
6993
|
if not UtilClient.is_unset(request.lang):
|
|
5524
6994
|
query['Lang'] = request.lang
|
|
5525
6995
|
if not UtilClient.is_unset(request.lang):
|
|
5526
6996
|
query['Lang'] = request.lang
|
|
5527
|
-
if not UtilClient.is_unset(request.
|
|
5528
|
-
query['
|
|
5529
|
-
if not UtilClient.is_unset(request.
|
|
5530
|
-
query['
|
|
5531
|
-
if not UtilClient.is_unset(request.owner_id):
|
|
5532
|
-
query['OwnerId'] = request.owner_id
|
|
5533
|
-
if not UtilClient.is_unset(request.page_size):
|
|
5534
|
-
query['PageSize'] = request.page_size
|
|
5535
|
-
if not UtilClient.is_unset(request.region_no):
|
|
5536
|
-
query['RegionNo'] = request.region_no
|
|
5537
|
-
if not UtilClient.is_unset(request.route_mode):
|
|
5538
|
-
query['RouteMode'] = request.route_mode
|
|
5539
|
-
if not UtilClient.is_unset(request.transit_router_type):
|
|
5540
|
-
query['TransitRouterType'] = request.transit_router_type
|
|
6997
|
+
if not UtilClient.is_unset(request.local_vpc_id):
|
|
6998
|
+
query['LocalVpcId'] = request.local_vpc_id
|
|
6999
|
+
if not UtilClient.is_unset(request.peer_vpc_id):
|
|
7000
|
+
query['PeerVpcId'] = request.peer_vpc_id
|
|
5541
7001
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5542
7002
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5543
|
-
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
5544
|
-
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
5545
7003
|
req = open_api_models.OpenApiRequest(
|
|
5546
7004
|
query=OpenApiUtilClient.query(query)
|
|
5547
7005
|
)
|
|
5548
7006
|
params = open_api_models.Params(
|
|
5549
|
-
action='
|
|
7007
|
+
action='DescribeVpcFirewallDetail',
|
|
5550
7008
|
version='2017-12-07',
|
|
5551
7009
|
protocol='HTTPS',
|
|
5552
7010
|
pathname='/',
|
|
@@ -5557,87 +7015,60 @@ class Client(OpenApiClient):
|
|
|
5557
7015
|
body_type='json'
|
|
5558
7016
|
)
|
|
5559
7017
|
return TeaCore.from_map(
|
|
5560
|
-
cloudfw_20171207_models.
|
|
7018
|
+
cloudfw_20171207_models.DescribeVpcFirewallDetailResponse(),
|
|
5561
7019
|
await self.call_api_async(params, req, runtime)
|
|
5562
7020
|
)
|
|
5563
7021
|
|
|
5564
|
-
def
|
|
7022
|
+
def describe_vpc_firewall_detail(
|
|
5565
7023
|
self,
|
|
5566
|
-
request: cloudfw_20171207_models.
|
|
5567
|
-
) -> cloudfw_20171207_models.
|
|
7024
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDetailRequest,
|
|
7025
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDetailResponse:
|
|
5568
7026
|
"""
|
|
5569
|
-
You can call the
|
|
7027
|
+
You can call the DescribeVpcFirewallDetail operation to query the details about a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
7028
|
+
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
5570
7029
|
## Limits
|
|
5571
7030
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5572
7031
|
|
|
5573
|
-
@param request:
|
|
5574
|
-
@return:
|
|
7032
|
+
@param request: DescribeVpcFirewallDetailRequest
|
|
7033
|
+
@return: DescribeVpcFirewallDetailResponse
|
|
5575
7034
|
"""
|
|
5576
7035
|
runtime = util_models.RuntimeOptions()
|
|
5577
|
-
return self.
|
|
7036
|
+
return self.describe_vpc_firewall_detail_with_options(request, runtime)
|
|
5578
7037
|
|
|
5579
|
-
async def
|
|
7038
|
+
async def describe_vpc_firewall_detail_async(
|
|
5580
7039
|
self,
|
|
5581
|
-
request: cloudfw_20171207_models.
|
|
5582
|
-
) -> cloudfw_20171207_models.
|
|
7040
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallDetailRequest,
|
|
7041
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallDetailResponse:
|
|
5583
7042
|
"""
|
|
5584
|
-
You can call the
|
|
7043
|
+
You can call the DescribeVpcFirewallDetail operation to query the details about a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
7044
|
+
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
5585
7045
|
## Limits
|
|
5586
7046
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5587
7047
|
|
|
5588
|
-
@param request:
|
|
5589
|
-
@return:
|
|
7048
|
+
@param request: DescribeVpcFirewallDetailRequest
|
|
7049
|
+
@return: DescribeVpcFirewallDetailResponse
|
|
5590
7050
|
"""
|
|
5591
7051
|
runtime = util_models.RuntimeOptions()
|
|
5592
|
-
return await self.
|
|
7052
|
+
return await self.describe_vpc_firewall_detail_with_options_async(request, runtime)
|
|
5593
7053
|
|
|
5594
|
-
def
|
|
7054
|
+
def describe_vpc_firewall_ipswhitelist_with_options(
|
|
5595
7055
|
self,
|
|
5596
|
-
request: cloudfw_20171207_models.
|
|
7056
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistRequest,
|
|
5597
7057
|
runtime: util_models.RuntimeOptions,
|
|
5598
|
-
) -> cloudfw_20171207_models.
|
|
5599
|
-
"""
|
|
5600
|
-
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5601
|
-
## Limits
|
|
5602
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5603
|
-
|
|
5604
|
-
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
5605
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
5606
|
-
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5607
|
-
"""
|
|
7058
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistResponse:
|
|
5608
7059
|
UtilClient.validate_model(request)
|
|
5609
7060
|
query = {}
|
|
5610
|
-
if not UtilClient.is_unset(request.acl_action):
|
|
5611
|
-
query['AclAction'] = request.acl_action
|
|
5612
|
-
if not UtilClient.is_unset(request.acl_uuid):
|
|
5613
|
-
query['AclUuid'] = request.acl_uuid
|
|
5614
|
-
if not UtilClient.is_unset(request.current_page):
|
|
5615
|
-
query['CurrentPage'] = request.current_page
|
|
5616
|
-
if not UtilClient.is_unset(request.description):
|
|
5617
|
-
query['Description'] = request.description
|
|
5618
|
-
if not UtilClient.is_unset(request.destination):
|
|
5619
|
-
query['Destination'] = request.destination
|
|
5620
7061
|
if not UtilClient.is_unset(request.lang):
|
|
5621
7062
|
query['Lang'] = request.lang
|
|
5622
7063
|
if not UtilClient.is_unset(request.member_uid):
|
|
5623
7064
|
query['MemberUid'] = request.member_uid
|
|
5624
|
-
if not UtilClient.is_unset(request.page_size):
|
|
5625
|
-
query['PageSize'] = request.page_size
|
|
5626
|
-
if not UtilClient.is_unset(request.proto):
|
|
5627
|
-
query['Proto'] = request.proto
|
|
5628
|
-
if not UtilClient.is_unset(request.release):
|
|
5629
|
-
query['Release'] = request.release
|
|
5630
|
-
if not UtilClient.is_unset(request.repeat_type):
|
|
5631
|
-
query['RepeatType'] = request.repeat_type
|
|
5632
|
-
if not UtilClient.is_unset(request.source):
|
|
5633
|
-
query['Source'] = request.source
|
|
5634
7065
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5635
7066
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5636
7067
|
req = open_api_models.OpenApiRequest(
|
|
5637
7068
|
query=OpenApiUtilClient.query(query)
|
|
5638
7069
|
)
|
|
5639
7070
|
params = open_api_models.Params(
|
|
5640
|
-
action='
|
|
7071
|
+
action='DescribeVpcFirewallIPSWhitelist',
|
|
5641
7072
|
version='2017-12-07',
|
|
5642
7073
|
protocol='HTTPS',
|
|
5643
7074
|
pathname='/',
|
|
@@ -5648,57 +7079,28 @@ class Client(OpenApiClient):
|
|
|
5648
7079
|
body_type='json'
|
|
5649
7080
|
)
|
|
5650
7081
|
return TeaCore.from_map(
|
|
5651
|
-
cloudfw_20171207_models.
|
|
7082
|
+
cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistResponse(),
|
|
5652
7083
|
self.call_api(params, req, runtime)
|
|
5653
7084
|
)
|
|
5654
7085
|
|
|
5655
|
-
async def
|
|
7086
|
+
async def describe_vpc_firewall_ipswhitelist_with_options_async(
|
|
5656
7087
|
self,
|
|
5657
|
-
request: cloudfw_20171207_models.
|
|
7088
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistRequest,
|
|
5658
7089
|
runtime: util_models.RuntimeOptions,
|
|
5659
|
-
) -> cloudfw_20171207_models.
|
|
5660
|
-
"""
|
|
5661
|
-
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5662
|
-
## Limits
|
|
5663
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5664
|
-
|
|
5665
|
-
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
5666
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
5667
|
-
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5668
|
-
"""
|
|
7090
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistResponse:
|
|
5669
7091
|
UtilClient.validate_model(request)
|
|
5670
7092
|
query = {}
|
|
5671
|
-
if not UtilClient.is_unset(request.acl_action):
|
|
5672
|
-
query['AclAction'] = request.acl_action
|
|
5673
|
-
if not UtilClient.is_unset(request.acl_uuid):
|
|
5674
|
-
query['AclUuid'] = request.acl_uuid
|
|
5675
|
-
if not UtilClient.is_unset(request.current_page):
|
|
5676
|
-
query['CurrentPage'] = request.current_page
|
|
5677
|
-
if not UtilClient.is_unset(request.description):
|
|
5678
|
-
query['Description'] = request.description
|
|
5679
|
-
if not UtilClient.is_unset(request.destination):
|
|
5680
|
-
query['Destination'] = request.destination
|
|
5681
7093
|
if not UtilClient.is_unset(request.lang):
|
|
5682
7094
|
query['Lang'] = request.lang
|
|
5683
7095
|
if not UtilClient.is_unset(request.member_uid):
|
|
5684
7096
|
query['MemberUid'] = request.member_uid
|
|
5685
|
-
if not UtilClient.is_unset(request.page_size):
|
|
5686
|
-
query['PageSize'] = request.page_size
|
|
5687
|
-
if not UtilClient.is_unset(request.proto):
|
|
5688
|
-
query['Proto'] = request.proto
|
|
5689
|
-
if not UtilClient.is_unset(request.release):
|
|
5690
|
-
query['Release'] = request.release
|
|
5691
|
-
if not UtilClient.is_unset(request.repeat_type):
|
|
5692
|
-
query['RepeatType'] = request.repeat_type
|
|
5693
|
-
if not UtilClient.is_unset(request.source):
|
|
5694
|
-
query['Source'] = request.source
|
|
5695
7097
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5696
7098
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5697
7099
|
req = open_api_models.OpenApiRequest(
|
|
5698
7100
|
query=OpenApiUtilClient.query(query)
|
|
5699
7101
|
)
|
|
5700
7102
|
params = open_api_models.Params(
|
|
5701
|
-
action='
|
|
7103
|
+
action='DescribeVpcFirewallIPSWhitelist',
|
|
5702
7104
|
version='2017-12-07',
|
|
5703
7105
|
protocol='HTTPS',
|
|
5704
7106
|
pathname='/',
|
|
@@ -5709,65 +7111,69 @@ class Client(OpenApiClient):
|
|
|
5709
7111
|
body_type='json'
|
|
5710
7112
|
)
|
|
5711
7113
|
return TeaCore.from_map(
|
|
5712
|
-
cloudfw_20171207_models.
|
|
7114
|
+
cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistResponse(),
|
|
5713
7115
|
await self.call_api_async(params, req, runtime)
|
|
5714
7116
|
)
|
|
5715
7117
|
|
|
5716
|
-
def
|
|
7118
|
+
def describe_vpc_firewall_ipswhitelist(
|
|
5717
7119
|
self,
|
|
5718
|
-
request: cloudfw_20171207_models.
|
|
5719
|
-
) -> cloudfw_20171207_models.
|
|
5720
|
-
"""
|
|
5721
|
-
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5722
|
-
## Limits
|
|
5723
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5724
|
-
|
|
5725
|
-
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
5726
|
-
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5727
|
-
"""
|
|
7120
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistRequest,
|
|
7121
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistResponse:
|
|
5728
7122
|
runtime = util_models.RuntimeOptions()
|
|
5729
|
-
return self.
|
|
7123
|
+
return self.describe_vpc_firewall_ipswhitelist_with_options(request, runtime)
|
|
5730
7124
|
|
|
5731
|
-
async def
|
|
7125
|
+
async def describe_vpc_firewall_ipswhitelist_async(
|
|
5732
7126
|
self,
|
|
5733
|
-
request: cloudfw_20171207_models.
|
|
5734
|
-
) -> cloudfw_20171207_models.
|
|
5735
|
-
"""
|
|
5736
|
-
You can call the DescribeVpcFirewallControlPolicy operation to query the information about all access control policies that are created for a specified VPC firewall. Different access control policies are used when a VPC firewall is used to protect traffic between two VPCs that are connected by using a Cloud Enterprise Network (CEN) instance or an Express Connect circuit.
|
|
5737
|
-
## Limits
|
|
5738
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5739
|
-
|
|
5740
|
-
@param request: DescribeVpcFirewallControlPolicyRequest
|
|
5741
|
-
@return: DescribeVpcFirewallControlPolicyResponse
|
|
5742
|
-
"""
|
|
7127
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistRequest,
|
|
7128
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallIPSWhitelistResponse:
|
|
5743
7129
|
runtime = util_models.RuntimeOptions()
|
|
5744
|
-
return await self.
|
|
7130
|
+
return await self.describe_vpc_firewall_ipswhitelist_with_options_async(request, runtime)
|
|
5745
7131
|
|
|
5746
|
-
def
|
|
7132
|
+
def describe_vpc_firewall_list_with_options(
|
|
5747
7133
|
self,
|
|
5748
|
-
request: cloudfw_20171207_models.
|
|
7134
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallListRequest,
|
|
5749
7135
|
runtime: util_models.RuntimeOptions,
|
|
5750
|
-
) -> cloudfw_20171207_models.
|
|
7136
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallListResponse:
|
|
5751
7137
|
"""
|
|
5752
|
-
You can call the
|
|
5753
|
-
|
|
5754
|
-
You can call this operation up to 10 times per second per account. If the number of
|
|
7138
|
+
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
7139
|
+
### Limits
|
|
7140
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5755
7141
|
|
|
5756
|
-
@param request:
|
|
7142
|
+
@param request: DescribeVpcFirewallListRequest
|
|
5757
7143
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5758
|
-
@return:
|
|
7144
|
+
@return: DescribeVpcFirewallListResponse
|
|
5759
7145
|
"""
|
|
5760
7146
|
UtilClient.validate_model(request)
|
|
5761
7147
|
query = {}
|
|
7148
|
+
if not UtilClient.is_unset(request.connect_sub_type):
|
|
7149
|
+
query['ConnectSubType'] = request.connect_sub_type
|
|
7150
|
+
if not UtilClient.is_unset(request.current_page):
|
|
7151
|
+
query['CurrentPage'] = request.current_page
|
|
7152
|
+
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
7153
|
+
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
7154
|
+
if not UtilClient.is_unset(request.lang):
|
|
7155
|
+
query['Lang'] = request.lang
|
|
7156
|
+
if not UtilClient.is_unset(request.lang):
|
|
7157
|
+
query['Lang'] = request.lang
|
|
5762
7158
|
if not UtilClient.is_unset(request.member_uid):
|
|
5763
7159
|
query['MemberUid'] = request.member_uid
|
|
7160
|
+
if not UtilClient.is_unset(request.page_size):
|
|
7161
|
+
query['PageSize'] = request.page_size
|
|
7162
|
+
if not UtilClient.is_unset(request.peer_uid):
|
|
7163
|
+
query['PeerUid'] = request.peer_uid
|
|
7164
|
+
if not UtilClient.is_unset(request.region_no):
|
|
7165
|
+
query['RegionNo'] = request.region_no
|
|
5764
7166
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5765
7167
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
7168
|
+
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
7169
|
+
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
7170
|
+
if not UtilClient.is_unset(request.vpc_id):
|
|
7171
|
+
query['VpcId'] = request.vpc_id
|
|
5766
7172
|
req = open_api_models.OpenApiRequest(
|
|
5767
7173
|
query=OpenApiUtilClient.query(query)
|
|
5768
7174
|
)
|
|
5769
7175
|
params = open_api_models.Params(
|
|
5770
|
-
action='
|
|
7176
|
+
action='DescribeVpcFirewallList',
|
|
5771
7177
|
version='2017-12-07',
|
|
5772
7178
|
protocol='HTTPS',
|
|
5773
7179
|
pathname='/',
|
|
@@ -5778,35 +7184,55 @@ class Client(OpenApiClient):
|
|
|
5778
7184
|
body_type='json'
|
|
5779
7185
|
)
|
|
5780
7186
|
return TeaCore.from_map(
|
|
5781
|
-
cloudfw_20171207_models.
|
|
7187
|
+
cloudfw_20171207_models.DescribeVpcFirewallListResponse(),
|
|
5782
7188
|
self.call_api(params, req, runtime)
|
|
5783
7189
|
)
|
|
5784
7190
|
|
|
5785
|
-
async def
|
|
7191
|
+
async def describe_vpc_firewall_list_with_options_async(
|
|
5786
7192
|
self,
|
|
5787
|
-
request: cloudfw_20171207_models.
|
|
7193
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallListRequest,
|
|
5788
7194
|
runtime: util_models.RuntimeOptions,
|
|
5789
|
-
) -> cloudfw_20171207_models.
|
|
7195
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallListResponse:
|
|
5790
7196
|
"""
|
|
5791
|
-
You can call the
|
|
5792
|
-
|
|
5793
|
-
You can call this operation up to 10 times per second per account. If the number of
|
|
7197
|
+
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
7198
|
+
### Limits
|
|
7199
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5794
7200
|
|
|
5795
|
-
@param request:
|
|
7201
|
+
@param request: DescribeVpcFirewallListRequest
|
|
5796
7202
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5797
|
-
@return:
|
|
7203
|
+
@return: DescribeVpcFirewallListResponse
|
|
5798
7204
|
"""
|
|
5799
7205
|
UtilClient.validate_model(request)
|
|
5800
7206
|
query = {}
|
|
7207
|
+
if not UtilClient.is_unset(request.connect_sub_type):
|
|
7208
|
+
query['ConnectSubType'] = request.connect_sub_type
|
|
7209
|
+
if not UtilClient.is_unset(request.current_page):
|
|
7210
|
+
query['CurrentPage'] = request.current_page
|
|
7211
|
+
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
7212
|
+
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
7213
|
+
if not UtilClient.is_unset(request.lang):
|
|
7214
|
+
query['Lang'] = request.lang
|
|
7215
|
+
if not UtilClient.is_unset(request.lang):
|
|
7216
|
+
query['Lang'] = request.lang
|
|
5801
7217
|
if not UtilClient.is_unset(request.member_uid):
|
|
5802
7218
|
query['MemberUid'] = request.member_uid
|
|
7219
|
+
if not UtilClient.is_unset(request.page_size):
|
|
7220
|
+
query['PageSize'] = request.page_size
|
|
7221
|
+
if not UtilClient.is_unset(request.peer_uid):
|
|
7222
|
+
query['PeerUid'] = request.peer_uid
|
|
7223
|
+
if not UtilClient.is_unset(request.region_no):
|
|
7224
|
+
query['RegionNo'] = request.region_no
|
|
5803
7225
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5804
7226
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
7227
|
+
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
7228
|
+
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
7229
|
+
if not UtilClient.is_unset(request.vpc_id):
|
|
7230
|
+
query['VpcId'] = request.vpc_id
|
|
5805
7231
|
req = open_api_models.OpenApiRequest(
|
|
5806
7232
|
query=OpenApiUtilClient.query(query)
|
|
5807
7233
|
)
|
|
5808
7234
|
params = open_api_models.Params(
|
|
5809
|
-
action='
|
|
7235
|
+
action='DescribeVpcFirewallList',
|
|
5810
7236
|
version='2017-12-07',
|
|
5811
7237
|
protocol='HTTPS',
|
|
5812
7238
|
pathname='/',
|
|
@@ -5817,72 +7243,65 @@ class Client(OpenApiClient):
|
|
|
5817
7243
|
body_type='json'
|
|
5818
7244
|
)
|
|
5819
7245
|
return TeaCore.from_map(
|
|
5820
|
-
cloudfw_20171207_models.
|
|
7246
|
+
cloudfw_20171207_models.DescribeVpcFirewallListResponse(),
|
|
5821
7247
|
await self.call_api_async(params, req, runtime)
|
|
5822
7248
|
)
|
|
5823
7249
|
|
|
5824
|
-
def
|
|
7250
|
+
def describe_vpc_firewall_list(
|
|
5825
7251
|
self,
|
|
5826
|
-
request: cloudfw_20171207_models.
|
|
5827
|
-
) -> cloudfw_20171207_models.
|
|
7252
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallListRequest,
|
|
7253
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallListResponse:
|
|
5828
7254
|
"""
|
|
5829
|
-
You can call the
|
|
5830
|
-
|
|
5831
|
-
You can call this operation up to 10 times per second per account. If the number of
|
|
7255
|
+
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
7256
|
+
### Limits
|
|
7257
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5832
7258
|
|
|
5833
|
-
@param request:
|
|
5834
|
-
@return:
|
|
7259
|
+
@param request: DescribeVpcFirewallListRequest
|
|
7260
|
+
@return: DescribeVpcFirewallListResponse
|
|
5835
7261
|
"""
|
|
5836
7262
|
runtime = util_models.RuntimeOptions()
|
|
5837
|
-
return self.
|
|
7263
|
+
return self.describe_vpc_firewall_list_with_options(request, runtime)
|
|
5838
7264
|
|
|
5839
|
-
async def
|
|
7265
|
+
async def describe_vpc_firewall_list_async(
|
|
5840
7266
|
self,
|
|
5841
|
-
request: cloudfw_20171207_models.
|
|
5842
|
-
) -> cloudfw_20171207_models.
|
|
7267
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallListRequest,
|
|
7268
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallListResponse:
|
|
5843
7269
|
"""
|
|
5844
|
-
You can call the
|
|
5845
|
-
|
|
5846
|
-
You can call this operation up to 10 times per second per account. If the number of
|
|
7270
|
+
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
7271
|
+
### Limits
|
|
7272
|
+
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5847
7273
|
|
|
5848
|
-
@param request:
|
|
5849
|
-
@return:
|
|
7274
|
+
@param request: DescribeVpcFirewallListRequest
|
|
7275
|
+
@return: DescribeVpcFirewallListResponse
|
|
5850
7276
|
"""
|
|
5851
7277
|
runtime = util_models.RuntimeOptions()
|
|
5852
|
-
return await self.
|
|
7278
|
+
return await self.describe_vpc_firewall_list_with_options_async(request, runtime)
|
|
5853
7279
|
|
|
5854
|
-
def
|
|
7280
|
+
def describe_vpc_firewall_policy_prior_used_with_options(
|
|
5855
7281
|
self,
|
|
5856
|
-
request: cloudfw_20171207_models.
|
|
7282
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedRequest,
|
|
5857
7283
|
runtime: util_models.RuntimeOptions,
|
|
5858
|
-
) -> cloudfw_20171207_models.
|
|
7284
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedResponse:
|
|
5859
7285
|
"""
|
|
5860
|
-
You can call the
|
|
5861
|
-
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
7286
|
+
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
5862
7287
|
## Limits
|
|
5863
7288
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5864
7289
|
|
|
5865
|
-
@param request:
|
|
7290
|
+
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
5866
7291
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5867
|
-
@return:
|
|
7292
|
+
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
5868
7293
|
"""
|
|
5869
7294
|
UtilClient.validate_model(request)
|
|
5870
7295
|
query = {}
|
|
5871
7296
|
if not UtilClient.is_unset(request.lang):
|
|
5872
7297
|
query['Lang'] = request.lang
|
|
5873
|
-
if not UtilClient.is_unset(request.lang):
|
|
5874
|
-
query['Lang'] = request.lang
|
|
5875
|
-
if not UtilClient.is_unset(request.local_vpc_id):
|
|
5876
|
-
query['LocalVpcId'] = request.local_vpc_id
|
|
5877
|
-
if not UtilClient.is_unset(request.peer_vpc_id):
|
|
5878
|
-
query['PeerVpcId'] = request.peer_vpc_id
|
|
5879
7298
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5880
7299
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5881
7300
|
req = open_api_models.OpenApiRequest(
|
|
5882
7301
|
query=OpenApiUtilClient.query(query)
|
|
5883
7302
|
)
|
|
5884
7303
|
params = open_api_models.Params(
|
|
5885
|
-
action='
|
|
7304
|
+
action='DescribeVpcFirewallPolicyPriorUsed',
|
|
5886
7305
|
version='2017-12-07',
|
|
5887
7306
|
protocol='HTTPS',
|
|
5888
7307
|
pathname='/',
|
|
@@ -5893,42 +7312,35 @@ class Client(OpenApiClient):
|
|
|
5893
7312
|
body_type='json'
|
|
5894
7313
|
)
|
|
5895
7314
|
return TeaCore.from_map(
|
|
5896
|
-
cloudfw_20171207_models.
|
|
7315
|
+
cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedResponse(),
|
|
5897
7316
|
self.call_api(params, req, runtime)
|
|
5898
7317
|
)
|
|
5899
7318
|
|
|
5900
|
-
async def
|
|
7319
|
+
async def describe_vpc_firewall_policy_prior_used_with_options_async(
|
|
5901
7320
|
self,
|
|
5902
|
-
request: cloudfw_20171207_models.
|
|
7321
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedRequest,
|
|
5903
7322
|
runtime: util_models.RuntimeOptions,
|
|
5904
|
-
) -> cloudfw_20171207_models.
|
|
7323
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedResponse:
|
|
5905
7324
|
"""
|
|
5906
|
-
You can call the
|
|
5907
|
-
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
7325
|
+
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
5908
7326
|
## Limits
|
|
5909
7327
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5910
7328
|
|
|
5911
|
-
@param request:
|
|
7329
|
+
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
5912
7330
|
@param runtime: runtime options for this request RuntimeOptions
|
|
5913
|
-
@return:
|
|
7331
|
+
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
5914
7332
|
"""
|
|
5915
7333
|
UtilClient.validate_model(request)
|
|
5916
7334
|
query = {}
|
|
5917
7335
|
if not UtilClient.is_unset(request.lang):
|
|
5918
7336
|
query['Lang'] = request.lang
|
|
5919
|
-
if not UtilClient.is_unset(request.lang):
|
|
5920
|
-
query['Lang'] = request.lang
|
|
5921
|
-
if not UtilClient.is_unset(request.local_vpc_id):
|
|
5922
|
-
query['LocalVpcId'] = request.local_vpc_id
|
|
5923
|
-
if not UtilClient.is_unset(request.peer_vpc_id):
|
|
5924
|
-
query['PeerVpcId'] = request.peer_vpc_id
|
|
5925
7337
|
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
5926
7338
|
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
5927
7339
|
req = open_api_models.OpenApiRequest(
|
|
5928
7340
|
query=OpenApiUtilClient.query(query)
|
|
5929
7341
|
)
|
|
5930
7342
|
params = open_api_models.Params(
|
|
5931
|
-
action='
|
|
7343
|
+
action='DescribeVpcFirewallPolicyPriorUsed',
|
|
5932
7344
|
version='2017-12-07',
|
|
5933
7345
|
protocol='HTTPS',
|
|
5934
7346
|
pathname='/',
|
|
@@ -5939,87 +7351,62 @@ class Client(OpenApiClient):
|
|
|
5939
7351
|
body_type='json'
|
|
5940
7352
|
)
|
|
5941
7353
|
return TeaCore.from_map(
|
|
5942
|
-
cloudfw_20171207_models.
|
|
7354
|
+
cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedResponse(),
|
|
5943
7355
|
await self.call_api_async(params, req, runtime)
|
|
5944
7356
|
)
|
|
5945
7357
|
|
|
5946
|
-
def
|
|
7358
|
+
def describe_vpc_firewall_policy_prior_used(
|
|
5947
7359
|
self,
|
|
5948
|
-
request: cloudfw_20171207_models.
|
|
5949
|
-
) -> cloudfw_20171207_models.
|
|
7360
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedRequest,
|
|
7361
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedResponse:
|
|
5950
7362
|
"""
|
|
5951
|
-
You can call the
|
|
5952
|
-
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
7363
|
+
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
5953
7364
|
## Limits
|
|
5954
7365
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5955
7366
|
|
|
5956
|
-
@param request:
|
|
5957
|
-
@return:
|
|
7367
|
+
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
7368
|
+
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
5958
7369
|
"""
|
|
5959
7370
|
runtime = util_models.RuntimeOptions()
|
|
5960
|
-
return self.
|
|
7371
|
+
return self.describe_vpc_firewall_policy_prior_used_with_options(request, runtime)
|
|
5961
7372
|
|
|
5962
|
-
async def
|
|
7373
|
+
async def describe_vpc_firewall_policy_prior_used_async(
|
|
5963
7374
|
self,
|
|
5964
|
-
request: cloudfw_20171207_models.
|
|
5965
|
-
) -> cloudfw_20171207_models.
|
|
7375
|
+
request: cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedRequest,
|
|
7376
|
+
) -> cloudfw_20171207_models.DescribeVpcFirewallPolicyPriorUsedResponse:
|
|
5966
7377
|
"""
|
|
5967
|
-
You can call the
|
|
5968
|
-
Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](https://www.alibabacloud.com/help/en/cloud-firewall/latest/createvpcfirewallconfigure) operation.
|
|
7378
|
+
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
5969
7379
|
## Limits
|
|
5970
7380
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5971
7381
|
|
|
5972
|
-
@param request:
|
|
5973
|
-
@return:
|
|
7382
|
+
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
7383
|
+
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
5974
7384
|
"""
|
|
5975
7385
|
runtime = util_models.RuntimeOptions()
|
|
5976
|
-
return await self.
|
|
7386
|
+
return await self.describe_vpc_firewall_policy_prior_used_with_options_async(request, runtime)
|
|
5977
7387
|
|
|
5978
|
-
def
|
|
7388
|
+
def describe_vpc_list_lite_with_options(
|
|
5979
7389
|
self,
|
|
5980
|
-
request: cloudfw_20171207_models.
|
|
7390
|
+
request: cloudfw_20171207_models.DescribeVpcListLiteRequest,
|
|
5981
7391
|
runtime: util_models.RuntimeOptions,
|
|
5982
|
-
) -> cloudfw_20171207_models.
|
|
5983
|
-
"""
|
|
5984
|
-
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
5985
|
-
### Limits
|
|
5986
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
5987
|
-
|
|
5988
|
-
@param request: DescribeVpcFirewallListRequest
|
|
5989
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
5990
|
-
@return: DescribeVpcFirewallListResponse
|
|
5991
|
-
"""
|
|
7392
|
+
) -> cloudfw_20171207_models.DescribeVpcListLiteResponse:
|
|
5992
7393
|
UtilClient.validate_model(request)
|
|
5993
7394
|
query = {}
|
|
5994
|
-
if not UtilClient.is_unset(request.connect_sub_type):
|
|
5995
|
-
query['ConnectSubType'] = request.connect_sub_type
|
|
5996
|
-
if not UtilClient.is_unset(request.current_page):
|
|
5997
|
-
query['CurrentPage'] = request.current_page
|
|
5998
|
-
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
5999
|
-
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
6000
|
-
if not UtilClient.is_unset(request.lang):
|
|
6001
|
-
query['Lang'] = request.lang
|
|
6002
7395
|
if not UtilClient.is_unset(request.lang):
|
|
6003
7396
|
query['Lang'] = request.lang
|
|
6004
|
-
if not UtilClient.is_unset(request.member_uid):
|
|
6005
|
-
query['MemberUid'] = request.member_uid
|
|
6006
|
-
if not UtilClient.is_unset(request.page_size):
|
|
6007
|
-
query['PageSize'] = request.page_size
|
|
6008
|
-
if not UtilClient.is_unset(request.peer_uid):
|
|
6009
|
-
query['PeerUid'] = request.peer_uid
|
|
6010
7397
|
if not UtilClient.is_unset(request.region_no):
|
|
6011
7398
|
query['RegionNo'] = request.region_no
|
|
6012
|
-
if not UtilClient.is_unset(request.
|
|
6013
|
-
query['
|
|
6014
|
-
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
6015
|
-
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
7399
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
7400
|
+
query['SourceIp'] = request.source_ip
|
|
6016
7401
|
if not UtilClient.is_unset(request.vpc_id):
|
|
6017
7402
|
query['VpcId'] = request.vpc_id
|
|
7403
|
+
if not UtilClient.is_unset(request.vpc_name):
|
|
7404
|
+
query['VpcName'] = request.vpc_name
|
|
6018
7405
|
req = open_api_models.OpenApiRequest(
|
|
6019
7406
|
query=OpenApiUtilClient.query(query)
|
|
6020
7407
|
)
|
|
6021
7408
|
params = open_api_models.Params(
|
|
6022
|
-
action='
|
|
7409
|
+
action='DescribeVpcListLite',
|
|
6023
7410
|
version='2017-12-07',
|
|
6024
7411
|
protocol='HTTPS',
|
|
6025
7412
|
pathname='/',
|
|
@@ -6029,56 +7416,33 @@ class Client(OpenApiClient):
|
|
|
6029
7416
|
req_body_type='formData',
|
|
6030
7417
|
body_type='json'
|
|
6031
7418
|
)
|
|
6032
|
-
return TeaCore.from_map(
|
|
6033
|
-
cloudfw_20171207_models.
|
|
6034
|
-
self.call_api(params, req, runtime)
|
|
6035
|
-
)
|
|
6036
|
-
|
|
6037
|
-
async def
|
|
6038
|
-
self,
|
|
6039
|
-
request: cloudfw_20171207_models.
|
|
6040
|
-
runtime: util_models.RuntimeOptions,
|
|
6041
|
-
) -> cloudfw_20171207_models.
|
|
6042
|
-
"""
|
|
6043
|
-
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
6044
|
-
### Limits
|
|
6045
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6046
|
-
|
|
6047
|
-
@param request: DescribeVpcFirewallListRequest
|
|
6048
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
6049
|
-
@return: DescribeVpcFirewallListResponse
|
|
6050
|
-
"""
|
|
7419
|
+
return TeaCore.from_map(
|
|
7420
|
+
cloudfw_20171207_models.DescribeVpcListLiteResponse(),
|
|
7421
|
+
self.call_api(params, req, runtime)
|
|
7422
|
+
)
|
|
7423
|
+
|
|
7424
|
+
async def describe_vpc_list_lite_with_options_async(
|
|
7425
|
+
self,
|
|
7426
|
+
request: cloudfw_20171207_models.DescribeVpcListLiteRequest,
|
|
7427
|
+
runtime: util_models.RuntimeOptions,
|
|
7428
|
+
) -> cloudfw_20171207_models.DescribeVpcListLiteResponse:
|
|
6051
7429
|
UtilClient.validate_model(request)
|
|
6052
7430
|
query = {}
|
|
6053
|
-
if not UtilClient.is_unset(request.connect_sub_type):
|
|
6054
|
-
query['ConnectSubType'] = request.connect_sub_type
|
|
6055
|
-
if not UtilClient.is_unset(request.current_page):
|
|
6056
|
-
query['CurrentPage'] = request.current_page
|
|
6057
|
-
if not UtilClient.is_unset(request.firewall_switch_status):
|
|
6058
|
-
query['FirewallSwitchStatus'] = request.firewall_switch_status
|
|
6059
7431
|
if not UtilClient.is_unset(request.lang):
|
|
6060
7432
|
query['Lang'] = request.lang
|
|
6061
|
-
if not UtilClient.is_unset(request.lang):
|
|
6062
|
-
query['Lang'] = request.lang
|
|
6063
|
-
if not UtilClient.is_unset(request.member_uid):
|
|
6064
|
-
query['MemberUid'] = request.member_uid
|
|
6065
|
-
if not UtilClient.is_unset(request.page_size):
|
|
6066
|
-
query['PageSize'] = request.page_size
|
|
6067
|
-
if not UtilClient.is_unset(request.peer_uid):
|
|
6068
|
-
query['PeerUid'] = request.peer_uid
|
|
6069
7433
|
if not UtilClient.is_unset(request.region_no):
|
|
6070
7434
|
query['RegionNo'] = request.region_no
|
|
6071
|
-
if not UtilClient.is_unset(request.
|
|
6072
|
-
query['
|
|
6073
|
-
if not UtilClient.is_unset(request.vpc_firewall_name):
|
|
6074
|
-
query['VpcFirewallName'] = request.vpc_firewall_name
|
|
7435
|
+
if not UtilClient.is_unset(request.source_ip):
|
|
7436
|
+
query['SourceIp'] = request.source_ip
|
|
6075
7437
|
if not UtilClient.is_unset(request.vpc_id):
|
|
6076
7438
|
query['VpcId'] = request.vpc_id
|
|
7439
|
+
if not UtilClient.is_unset(request.vpc_name):
|
|
7440
|
+
query['VpcName'] = request.vpc_name
|
|
6077
7441
|
req = open_api_models.OpenApiRequest(
|
|
6078
7442
|
query=OpenApiUtilClient.query(query)
|
|
6079
7443
|
)
|
|
6080
7444
|
params = open_api_models.Params(
|
|
6081
|
-
action='
|
|
7445
|
+
action='DescribeVpcListLite',
|
|
6082
7446
|
version='2017-12-07',
|
|
6083
7447
|
protocol='HTTPS',
|
|
6084
7448
|
pathname='/',
|
|
@@ -6089,65 +7453,44 @@ class Client(OpenApiClient):
|
|
|
6089
7453
|
body_type='json'
|
|
6090
7454
|
)
|
|
6091
7455
|
return TeaCore.from_map(
|
|
6092
|
-
cloudfw_20171207_models.
|
|
7456
|
+
cloudfw_20171207_models.DescribeVpcListLiteResponse(),
|
|
6093
7457
|
await self.call_api_async(params, req, runtime)
|
|
6094
7458
|
)
|
|
6095
7459
|
|
|
6096
|
-
def
|
|
7460
|
+
def describe_vpc_list_lite(
|
|
6097
7461
|
self,
|
|
6098
|
-
request: cloudfw_20171207_models.
|
|
6099
|
-
) -> cloudfw_20171207_models.
|
|
6100
|
-
"""
|
|
6101
|
-
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
6102
|
-
### Limits
|
|
6103
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6104
|
-
|
|
6105
|
-
@param request: DescribeVpcFirewallListRequest
|
|
6106
|
-
@return: DescribeVpcFirewallListResponse
|
|
6107
|
-
"""
|
|
7462
|
+
request: cloudfw_20171207_models.DescribeVpcListLiteRequest,
|
|
7463
|
+
) -> cloudfw_20171207_models.DescribeVpcListLiteResponse:
|
|
6108
7464
|
runtime = util_models.RuntimeOptions()
|
|
6109
|
-
return self.
|
|
7465
|
+
return self.describe_vpc_list_lite_with_options(request, runtime)
|
|
6110
7466
|
|
|
6111
|
-
async def
|
|
7467
|
+
async def describe_vpc_list_lite_async(
|
|
6112
7468
|
self,
|
|
6113
|
-
request: cloudfw_20171207_models.
|
|
6114
|
-
) -> cloudfw_20171207_models.
|
|
6115
|
-
"""
|
|
6116
|
-
You can call the DescribeVpcFirewallList operation to query the details about VPC firewalls by page. Each VPC firewall protects traffic between two VPCs that are connected by using an Express Connect circuit.
|
|
6117
|
-
### Limits
|
|
6118
|
-
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6119
|
-
|
|
6120
|
-
@param request: DescribeVpcFirewallListRequest
|
|
6121
|
-
@return: DescribeVpcFirewallListResponse
|
|
6122
|
-
"""
|
|
7469
|
+
request: cloudfw_20171207_models.DescribeVpcListLiteRequest,
|
|
7470
|
+
) -> cloudfw_20171207_models.DescribeVpcListLiteResponse:
|
|
6123
7471
|
runtime = util_models.RuntimeOptions()
|
|
6124
|
-
return await self.
|
|
7472
|
+
return await self.describe_vpc_list_lite_with_options_async(request, runtime)
|
|
6125
7473
|
|
|
6126
|
-
def
|
|
7474
|
+
def describe_vpc_zone_with_options(
|
|
6127
7475
|
self,
|
|
6128
|
-
request: cloudfw_20171207_models.
|
|
7476
|
+
request: cloudfw_20171207_models.DescribeVpcZoneRequest,
|
|
6129
7477
|
runtime: util_models.RuntimeOptions,
|
|
6130
|
-
) -> cloudfw_20171207_models.
|
|
6131
|
-
"""
|
|
6132
|
-
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
6133
|
-
## Limits
|
|
6134
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6135
|
-
|
|
6136
|
-
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
6137
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
6138
|
-
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
6139
|
-
"""
|
|
7478
|
+
) -> cloudfw_20171207_models.DescribeVpcZoneResponse:
|
|
6140
7479
|
UtilClient.validate_model(request)
|
|
6141
7480
|
query = {}
|
|
7481
|
+
if not UtilClient.is_unset(request.environment):
|
|
7482
|
+
query['Environment'] = request.environment
|
|
6142
7483
|
if not UtilClient.is_unset(request.lang):
|
|
6143
7484
|
query['Lang'] = request.lang
|
|
6144
|
-
if not UtilClient.is_unset(request.
|
|
6145
|
-
query['
|
|
7485
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
7486
|
+
query['MemberUid'] = request.member_uid
|
|
7487
|
+
if not UtilClient.is_unset(request.region_no):
|
|
7488
|
+
query['RegionNo'] = request.region_no
|
|
6146
7489
|
req = open_api_models.OpenApiRequest(
|
|
6147
7490
|
query=OpenApiUtilClient.query(query)
|
|
6148
7491
|
)
|
|
6149
7492
|
params = open_api_models.Params(
|
|
6150
|
-
action='
|
|
7493
|
+
action='DescribeVpcZone',
|
|
6151
7494
|
version='2017-12-07',
|
|
6152
7495
|
protocol='HTTPS',
|
|
6153
7496
|
pathname='/',
|
|
@@ -6158,35 +7501,30 @@ class Client(OpenApiClient):
|
|
|
6158
7501
|
body_type='json'
|
|
6159
7502
|
)
|
|
6160
7503
|
return TeaCore.from_map(
|
|
6161
|
-
cloudfw_20171207_models.
|
|
7504
|
+
cloudfw_20171207_models.DescribeVpcZoneResponse(),
|
|
6162
7505
|
self.call_api(params, req, runtime)
|
|
6163
7506
|
)
|
|
6164
7507
|
|
|
6165
|
-
async def
|
|
7508
|
+
async def describe_vpc_zone_with_options_async(
|
|
6166
7509
|
self,
|
|
6167
|
-
request: cloudfw_20171207_models.
|
|
7510
|
+
request: cloudfw_20171207_models.DescribeVpcZoneRequest,
|
|
6168
7511
|
runtime: util_models.RuntimeOptions,
|
|
6169
|
-
) -> cloudfw_20171207_models.
|
|
6170
|
-
"""
|
|
6171
|
-
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
6172
|
-
## Limits
|
|
6173
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6174
|
-
|
|
6175
|
-
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
6176
|
-
@param runtime: runtime options for this request RuntimeOptions
|
|
6177
|
-
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
6178
|
-
"""
|
|
7512
|
+
) -> cloudfw_20171207_models.DescribeVpcZoneResponse:
|
|
6179
7513
|
UtilClient.validate_model(request)
|
|
6180
7514
|
query = {}
|
|
7515
|
+
if not UtilClient.is_unset(request.environment):
|
|
7516
|
+
query['Environment'] = request.environment
|
|
6181
7517
|
if not UtilClient.is_unset(request.lang):
|
|
6182
7518
|
query['Lang'] = request.lang
|
|
6183
|
-
if not UtilClient.is_unset(request.
|
|
6184
|
-
query['
|
|
7519
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
7520
|
+
query['MemberUid'] = request.member_uid
|
|
7521
|
+
if not UtilClient.is_unset(request.region_no):
|
|
7522
|
+
query['RegionNo'] = request.region_no
|
|
6185
7523
|
req = open_api_models.OpenApiRequest(
|
|
6186
7524
|
query=OpenApiUtilClient.query(query)
|
|
6187
7525
|
)
|
|
6188
7526
|
params = open_api_models.Params(
|
|
6189
|
-
action='
|
|
7527
|
+
action='DescribeVpcZone',
|
|
6190
7528
|
version='2017-12-07',
|
|
6191
7529
|
protocol='HTTPS',
|
|
6192
7530
|
pathname='/',
|
|
@@ -6197,39 +7535,23 @@ class Client(OpenApiClient):
|
|
|
6197
7535
|
body_type='json'
|
|
6198
7536
|
)
|
|
6199
7537
|
return TeaCore.from_map(
|
|
6200
|
-
cloudfw_20171207_models.
|
|
7538
|
+
cloudfw_20171207_models.DescribeVpcZoneResponse(),
|
|
6201
7539
|
await self.call_api_async(params, req, runtime)
|
|
6202
7540
|
)
|
|
6203
7541
|
|
|
6204
|
-
def
|
|
7542
|
+
def describe_vpc_zone(
|
|
6205
7543
|
self,
|
|
6206
|
-
request: cloudfw_20171207_models.
|
|
6207
|
-
) -> cloudfw_20171207_models.
|
|
6208
|
-
"""
|
|
6209
|
-
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
6210
|
-
## Limits
|
|
6211
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6212
|
-
|
|
6213
|
-
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
6214
|
-
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
6215
|
-
"""
|
|
7544
|
+
request: cloudfw_20171207_models.DescribeVpcZoneRequest,
|
|
7545
|
+
) -> cloudfw_20171207_models.DescribeVpcZoneResponse:
|
|
6216
7546
|
runtime = util_models.RuntimeOptions()
|
|
6217
|
-
return self.
|
|
7547
|
+
return self.describe_vpc_zone_with_options(request, runtime)
|
|
6218
7548
|
|
|
6219
|
-
async def
|
|
7549
|
+
async def describe_vpc_zone_async(
|
|
6220
7550
|
self,
|
|
6221
|
-
request: cloudfw_20171207_models.
|
|
6222
|
-
) -> cloudfw_20171207_models.
|
|
6223
|
-
"""
|
|
6224
|
-
You can call the DescribeVpcFirewallPolicyPriorUsed operation to query the priority range of access control policies that are created for a VPC firewall in a specific policy group.
|
|
6225
|
-
## Limits
|
|
6226
|
-
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6227
|
-
|
|
6228
|
-
@param request: DescribeVpcFirewallPolicyPriorUsedRequest
|
|
6229
|
-
@return: DescribeVpcFirewallPolicyPriorUsedResponse
|
|
6230
|
-
"""
|
|
7551
|
+
request: cloudfw_20171207_models.DescribeVpcZoneRequest,
|
|
7552
|
+
) -> cloudfw_20171207_models.DescribeVpcZoneResponse:
|
|
6231
7553
|
runtime = util_models.RuntimeOptions()
|
|
6232
|
-
return await self.
|
|
7554
|
+
return await self.describe_vpc_zone_with_options_async(request, runtime)
|
|
6233
7555
|
|
|
6234
7556
|
def describe_vulnerability_protected_list_with_options(
|
|
6235
7557
|
self,
|
|
@@ -6699,8 +8021,8 @@ class Client(OpenApiClient):
|
|
|
6699
8021
|
runtime: util_models.RuntimeOptions,
|
|
6700
8022
|
) -> cloudfw_20171207_models.ModifyControlPolicyPositionResponse:
|
|
6701
8023
|
"""
|
|
6702
|
-
You can
|
|
6703
|
-
## Limits
|
|
8024
|
+
You can use this operation to modify the priority of an IPv4 access control policy for the Internet firewall. No API operations are provided for you to modify the priority of an IPv6 access control policy for the Internet firewall.
|
|
8025
|
+
## [](#qps)Limits
|
|
6704
8026
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6705
8027
|
|
|
6706
8028
|
@param request: ModifyControlPolicyPositionRequest
|
|
@@ -6744,8 +8066,8 @@ class Client(OpenApiClient):
|
|
|
6744
8066
|
runtime: util_models.RuntimeOptions,
|
|
6745
8067
|
) -> cloudfw_20171207_models.ModifyControlPolicyPositionResponse:
|
|
6746
8068
|
"""
|
|
6747
|
-
You can
|
|
6748
|
-
## Limits
|
|
8069
|
+
You can use this operation to modify the priority of an IPv4 access control policy for the Internet firewall. No API operations are provided for you to modify the priority of an IPv6 access control policy for the Internet firewall.
|
|
8070
|
+
## [](#qps)Limits
|
|
6749
8071
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6750
8072
|
|
|
6751
8073
|
@param request: ModifyControlPolicyPositionRequest
|
|
@@ -6788,8 +8110,8 @@ class Client(OpenApiClient):
|
|
|
6788
8110
|
request: cloudfw_20171207_models.ModifyControlPolicyPositionRequest,
|
|
6789
8111
|
) -> cloudfw_20171207_models.ModifyControlPolicyPositionResponse:
|
|
6790
8112
|
"""
|
|
6791
|
-
You can
|
|
6792
|
-
## Limits
|
|
8113
|
+
You can use this operation to modify the priority of an IPv4 access control policy for the Internet firewall. No API operations are provided for you to modify the priority of an IPv6 access control policy for the Internet firewall.
|
|
8114
|
+
## [](#qps)Limits
|
|
6793
8115
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6794
8116
|
|
|
6795
8117
|
@param request: ModifyControlPolicyPositionRequest
|
|
@@ -6803,8 +8125,8 @@ class Client(OpenApiClient):
|
|
|
6803
8125
|
request: cloudfw_20171207_models.ModifyControlPolicyPositionRequest,
|
|
6804
8126
|
) -> cloudfw_20171207_models.ModifyControlPolicyPositionResponse:
|
|
6805
8127
|
"""
|
|
6806
|
-
You can
|
|
6807
|
-
## Limits
|
|
8128
|
+
You can use this operation to modify the priority of an IPv4 access control policy for the Internet firewall. No API operations are provided for you to modify the priority of an IPv6 access control policy for the Internet firewall.
|
|
8129
|
+
## [](#qps)Limits
|
|
6808
8130
|
You can call this operation up to 10 times per second per account. If the number of the calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
6809
8131
|
|
|
6810
8132
|
@param request: ModifyControlPolicyPositionRequest
|
|
@@ -7588,6 +8910,8 @@ class Client(OpenApiClient):
|
|
|
7588
8910
|
query['FirewallId'] = request.firewall_id
|
|
7589
8911
|
if not UtilClient.is_unset(request.lang):
|
|
7590
8912
|
query['Lang'] = request.lang
|
|
8913
|
+
if not UtilClient.is_unset(request.should_recover):
|
|
8914
|
+
query['ShouldRecover'] = request.should_recover
|
|
7591
8915
|
if not UtilClient.is_unset(request.src_candidate_list_shrink):
|
|
7592
8916
|
query['SrcCandidateList'] = request.src_candidate_list_shrink
|
|
7593
8917
|
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
@@ -7630,6 +8954,8 @@ class Client(OpenApiClient):
|
|
|
7630
8954
|
query['FirewallId'] = request.firewall_id
|
|
7631
8955
|
if not UtilClient.is_unset(request.lang):
|
|
7632
8956
|
query['Lang'] = request.lang
|
|
8957
|
+
if not UtilClient.is_unset(request.should_recover):
|
|
8958
|
+
query['ShouldRecover'] = request.should_recover
|
|
7633
8959
|
if not UtilClient.is_unset(request.src_candidate_list_shrink):
|
|
7634
8960
|
query['SrcCandidateList'] = request.src_candidate_list_shrink
|
|
7635
8961
|
if not UtilClient.is_unset(request.tr_firewall_route_policy_id):
|
|
@@ -8007,7 +9333,7 @@ class Client(OpenApiClient):
|
|
|
8007
9333
|
runtime: util_models.RuntimeOptions,
|
|
8008
9334
|
) -> cloudfw_20171207_models.ModifyVpcFirewallConfigureResponse:
|
|
8009
9335
|
"""
|
|
8010
|
-
You can call the
|
|
9336
|
+
You can call the ModifyVpcFirewallConfigure operation to modify the configurations of a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
8011
9337
|
## Limits
|
|
8012
9338
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
8013
9339
|
|
|
@@ -8054,7 +9380,7 @@ class Client(OpenApiClient):
|
|
|
8054
9380
|
runtime: util_models.RuntimeOptions,
|
|
8055
9381
|
) -> cloudfw_20171207_models.ModifyVpcFirewallConfigureResponse:
|
|
8056
9382
|
"""
|
|
8057
|
-
You can call the
|
|
9383
|
+
You can call the ModifyVpcFirewallConfigure operation to modify the configurations of a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
8058
9384
|
## Limits
|
|
8059
9385
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
8060
9386
|
|
|
@@ -8100,7 +9426,7 @@ class Client(OpenApiClient):
|
|
|
8100
9426
|
request: cloudfw_20171207_models.ModifyVpcFirewallConfigureRequest,
|
|
8101
9427
|
) -> cloudfw_20171207_models.ModifyVpcFirewallConfigureResponse:
|
|
8102
9428
|
"""
|
|
8103
|
-
You can call the
|
|
9429
|
+
You can call the ModifyVpcFirewallConfigure operation to modify the configurations of a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
8104
9430
|
## Limits
|
|
8105
9431
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
8106
9432
|
|
|
@@ -8115,7 +9441,7 @@ class Client(OpenApiClient):
|
|
|
8115
9441
|
request: cloudfw_20171207_models.ModifyVpcFirewallConfigureRequest,
|
|
8116
9442
|
) -> cloudfw_20171207_models.ModifyVpcFirewallConfigureResponse:
|
|
8117
9443
|
"""
|
|
8118
|
-
You can call the
|
|
9444
|
+
You can call the ModifyVpcFirewallConfigure operation to modify the configurations of a VPC firewall. The VPC firewall controls traffic between two VPCs that are connected by using an Express Connect circuit. Before you call the operation, make sure that you created a VPC firewall by calling the [CreateVpcFirewallConfigure](~~342893~~) operation.
|
|
8119
9445
|
## Limits
|
|
8120
9446
|
You can call this operation up to 10 times per second per account. If the number of calls per second exceeds the limit, throttling is triggered. As a result, your business may be affected. We recommend that you take note of the limit when you call this operation.
|
|
8121
9447
|
|
|
@@ -8561,6 +9887,96 @@ class Client(OpenApiClient):
|
|
|
8561
9887
|
runtime = util_models.RuntimeOptions()
|
|
8562
9888
|
return await self.modify_vpc_firewall_default_ipsconfig_with_options_async(request, runtime)
|
|
8563
9889
|
|
|
9890
|
+
def modify_vpc_firewall_ipswhitelist_with_options(
|
|
9891
|
+
self,
|
|
9892
|
+
request: cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistRequest,
|
|
9893
|
+
runtime: util_models.RuntimeOptions,
|
|
9894
|
+
) -> cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistResponse:
|
|
9895
|
+
UtilClient.validate_model(request)
|
|
9896
|
+
query = {}
|
|
9897
|
+
if not UtilClient.is_unset(request.lang):
|
|
9898
|
+
query['Lang'] = request.lang
|
|
9899
|
+
if not UtilClient.is_unset(request.list_type):
|
|
9900
|
+
query['ListType'] = request.list_type
|
|
9901
|
+
if not UtilClient.is_unset(request.list_value):
|
|
9902
|
+
query['ListValue'] = request.list_value
|
|
9903
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
9904
|
+
query['MemberUid'] = request.member_uid
|
|
9905
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
9906
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
9907
|
+
if not UtilClient.is_unset(request.white_type):
|
|
9908
|
+
query['WhiteType'] = request.white_type
|
|
9909
|
+
req = open_api_models.OpenApiRequest(
|
|
9910
|
+
query=OpenApiUtilClient.query(query)
|
|
9911
|
+
)
|
|
9912
|
+
params = open_api_models.Params(
|
|
9913
|
+
action='ModifyVpcFirewallIPSWhitelist',
|
|
9914
|
+
version='2017-12-07',
|
|
9915
|
+
protocol='HTTPS',
|
|
9916
|
+
pathname='/',
|
|
9917
|
+
method='POST',
|
|
9918
|
+
auth_type='AK',
|
|
9919
|
+
style='RPC',
|
|
9920
|
+
req_body_type='formData',
|
|
9921
|
+
body_type='json'
|
|
9922
|
+
)
|
|
9923
|
+
return TeaCore.from_map(
|
|
9924
|
+
cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistResponse(),
|
|
9925
|
+
self.call_api(params, req, runtime)
|
|
9926
|
+
)
|
|
9927
|
+
|
|
9928
|
+
async def modify_vpc_firewall_ipswhitelist_with_options_async(
|
|
9929
|
+
self,
|
|
9930
|
+
request: cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistRequest,
|
|
9931
|
+
runtime: util_models.RuntimeOptions,
|
|
9932
|
+
) -> cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistResponse:
|
|
9933
|
+
UtilClient.validate_model(request)
|
|
9934
|
+
query = {}
|
|
9935
|
+
if not UtilClient.is_unset(request.lang):
|
|
9936
|
+
query['Lang'] = request.lang
|
|
9937
|
+
if not UtilClient.is_unset(request.list_type):
|
|
9938
|
+
query['ListType'] = request.list_type
|
|
9939
|
+
if not UtilClient.is_unset(request.list_value):
|
|
9940
|
+
query['ListValue'] = request.list_value
|
|
9941
|
+
if not UtilClient.is_unset(request.member_uid):
|
|
9942
|
+
query['MemberUid'] = request.member_uid
|
|
9943
|
+
if not UtilClient.is_unset(request.vpc_firewall_id):
|
|
9944
|
+
query['VpcFirewallId'] = request.vpc_firewall_id
|
|
9945
|
+
if not UtilClient.is_unset(request.white_type):
|
|
9946
|
+
query['WhiteType'] = request.white_type
|
|
9947
|
+
req = open_api_models.OpenApiRequest(
|
|
9948
|
+
query=OpenApiUtilClient.query(query)
|
|
9949
|
+
)
|
|
9950
|
+
params = open_api_models.Params(
|
|
9951
|
+
action='ModifyVpcFirewallIPSWhitelist',
|
|
9952
|
+
version='2017-12-07',
|
|
9953
|
+
protocol='HTTPS',
|
|
9954
|
+
pathname='/',
|
|
9955
|
+
method='POST',
|
|
9956
|
+
auth_type='AK',
|
|
9957
|
+
style='RPC',
|
|
9958
|
+
req_body_type='formData',
|
|
9959
|
+
body_type='json'
|
|
9960
|
+
)
|
|
9961
|
+
return TeaCore.from_map(
|
|
9962
|
+
cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistResponse(),
|
|
9963
|
+
await self.call_api_async(params, req, runtime)
|
|
9964
|
+
)
|
|
9965
|
+
|
|
9966
|
+
def modify_vpc_firewall_ipswhitelist(
|
|
9967
|
+
self,
|
|
9968
|
+
request: cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistRequest,
|
|
9969
|
+
) -> cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistResponse:
|
|
9970
|
+
runtime = util_models.RuntimeOptions()
|
|
9971
|
+
return self.modify_vpc_firewall_ipswhitelist_with_options(request, runtime)
|
|
9972
|
+
|
|
9973
|
+
async def modify_vpc_firewall_ipswhitelist_async(
|
|
9974
|
+
self,
|
|
9975
|
+
request: cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistRequest,
|
|
9976
|
+
) -> cloudfw_20171207_models.ModifyVpcFirewallIPSWhitelistResponse:
|
|
9977
|
+
runtime = util_models.RuntimeOptions()
|
|
9978
|
+
return await self.modify_vpc_firewall_ipswhitelist_with_options_async(request, runtime)
|
|
9979
|
+
|
|
8564
9980
|
def modify_vpc_firewall_switch_status_with_options(
|
|
8565
9981
|
self,
|
|
8566
9982
|
request: cloudfw_20171207_models.ModifyVpcFirewallSwitchStatusRequest,
|
|
@@ -9215,6 +10631,84 @@ class Client(OpenApiClient):
|
|
|
9215
10631
|
runtime = util_models.RuntimeOptions()
|
|
9216
10632
|
return await self.release_post_instance_with_options_async(request, runtime)
|
|
9217
10633
|
|
|
10634
|
+
def reset_nat_firewall_rule_hit_count_with_options(
|
|
10635
|
+
self,
|
|
10636
|
+
request: cloudfw_20171207_models.ResetNatFirewallRuleHitCountRequest,
|
|
10637
|
+
runtime: util_models.RuntimeOptions,
|
|
10638
|
+
) -> cloudfw_20171207_models.ResetNatFirewallRuleHitCountResponse:
|
|
10639
|
+
UtilClient.validate_model(request)
|
|
10640
|
+
query = {}
|
|
10641
|
+
if not UtilClient.is_unset(request.acl_uuid):
|
|
10642
|
+
query['AclUuid'] = request.acl_uuid
|
|
10643
|
+
if not UtilClient.is_unset(request.lang):
|
|
10644
|
+
query['Lang'] = request.lang
|
|
10645
|
+
if not UtilClient.is_unset(request.nat_gateway_id):
|
|
10646
|
+
query['NatGatewayId'] = request.nat_gateway_id
|
|
10647
|
+
req = open_api_models.OpenApiRequest(
|
|
10648
|
+
query=OpenApiUtilClient.query(query)
|
|
10649
|
+
)
|
|
10650
|
+
params = open_api_models.Params(
|
|
10651
|
+
action='ResetNatFirewallRuleHitCount',
|
|
10652
|
+
version='2017-12-07',
|
|
10653
|
+
protocol='HTTPS',
|
|
10654
|
+
pathname='/',
|
|
10655
|
+
method='POST',
|
|
10656
|
+
auth_type='AK',
|
|
10657
|
+
style='RPC',
|
|
10658
|
+
req_body_type='formData',
|
|
10659
|
+
body_type='json'
|
|
10660
|
+
)
|
|
10661
|
+
return TeaCore.from_map(
|
|
10662
|
+
cloudfw_20171207_models.ResetNatFirewallRuleHitCountResponse(),
|
|
10663
|
+
self.call_api(params, req, runtime)
|
|
10664
|
+
)
|
|
10665
|
+
|
|
10666
|
+
async def reset_nat_firewall_rule_hit_count_with_options_async(
|
|
10667
|
+
self,
|
|
10668
|
+
request: cloudfw_20171207_models.ResetNatFirewallRuleHitCountRequest,
|
|
10669
|
+
runtime: util_models.RuntimeOptions,
|
|
10670
|
+
) -> cloudfw_20171207_models.ResetNatFirewallRuleHitCountResponse:
|
|
10671
|
+
UtilClient.validate_model(request)
|
|
10672
|
+
query = {}
|
|
10673
|
+
if not UtilClient.is_unset(request.acl_uuid):
|
|
10674
|
+
query['AclUuid'] = request.acl_uuid
|
|
10675
|
+
if not UtilClient.is_unset(request.lang):
|
|
10676
|
+
query['Lang'] = request.lang
|
|
10677
|
+
if not UtilClient.is_unset(request.nat_gateway_id):
|
|
10678
|
+
query['NatGatewayId'] = request.nat_gateway_id
|
|
10679
|
+
req = open_api_models.OpenApiRequest(
|
|
10680
|
+
query=OpenApiUtilClient.query(query)
|
|
10681
|
+
)
|
|
10682
|
+
params = open_api_models.Params(
|
|
10683
|
+
action='ResetNatFirewallRuleHitCount',
|
|
10684
|
+
version='2017-12-07',
|
|
10685
|
+
protocol='HTTPS',
|
|
10686
|
+
pathname='/',
|
|
10687
|
+
method='POST',
|
|
10688
|
+
auth_type='AK',
|
|
10689
|
+
style='RPC',
|
|
10690
|
+
req_body_type='formData',
|
|
10691
|
+
body_type='json'
|
|
10692
|
+
)
|
|
10693
|
+
return TeaCore.from_map(
|
|
10694
|
+
cloudfw_20171207_models.ResetNatFirewallRuleHitCountResponse(),
|
|
10695
|
+
await self.call_api_async(params, req, runtime)
|
|
10696
|
+
)
|
|
10697
|
+
|
|
10698
|
+
def reset_nat_firewall_rule_hit_count(
|
|
10699
|
+
self,
|
|
10700
|
+
request: cloudfw_20171207_models.ResetNatFirewallRuleHitCountRequest,
|
|
10701
|
+
) -> cloudfw_20171207_models.ResetNatFirewallRuleHitCountResponse:
|
|
10702
|
+
runtime = util_models.RuntimeOptions()
|
|
10703
|
+
return self.reset_nat_firewall_rule_hit_count_with_options(request, runtime)
|
|
10704
|
+
|
|
10705
|
+
async def reset_nat_firewall_rule_hit_count_async(
|
|
10706
|
+
self,
|
|
10707
|
+
request: cloudfw_20171207_models.ResetNatFirewallRuleHitCountRequest,
|
|
10708
|
+
) -> cloudfw_20171207_models.ResetNatFirewallRuleHitCountResponse:
|
|
10709
|
+
runtime = util_models.RuntimeOptions()
|
|
10710
|
+
return await self.reset_nat_firewall_rule_hit_count_with_options_async(request, runtime)
|
|
10711
|
+
|
|
9218
10712
|
def reset_vpc_firewall_rule_hit_count_with_options(
|
|
9219
10713
|
self,
|
|
9220
10714
|
request: cloudfw_20171207_models.ResetVpcFirewallRuleHitCountRequest,
|