tencentcloud-sdk-bmlb 1.0.200

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.
@@ -0,0 +1,4717 @@
1
+ # frozen_string_literal: true
2
+
3
+ # Copyright (c) 2017-2018 THL A29 Limited, a Tencent company. All Rights Reserved.
4
+ #
5
+ # Licensed under the Apache License, Version 2.0 (the "License");
6
+ # you may not use this file except in compliance with the License.
7
+ # You may obtain a copy of the License at
8
+ #
9
+ # http://www.apache.org/licenses/LICENSE-2.0
10
+ #
11
+ # Unless required by applicable law or agreed to in writing, software
12
+ # distributed under the License is distributed on an "AS IS" BASIS,
13
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
+ # See the License for the specific language governing permissions and
15
+ # limitations under the License.
16
+
17
+ module TencentCloud
18
+ module Bmlb
19
+ module V20180625
20
+ # 待与四层监听器绑定的物理机主机、虚拟机或半托管主机信息。目前一个四层监听器下面最多允许绑定255个主机端口。
21
+ class BindL4Backend < TencentCloud::Common::AbstractModel
22
+ # @param Port: 待绑定的主机端口,可选值1~65535。
23
+ # @type Port: Integer
24
+ # @param InstanceId: 待绑定的黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
25
+ # @type InstanceId: String
26
+ # @param Weight: 待绑定的主机权重,可选值0~100。
27
+ # @type Weight: Integer
28
+ # @param ProbePort: 自定义探测的主机端口,可选值1~65535。(需要监听器开启自定义健康检查)
29
+ # @type ProbePort: Integer
30
+
31
+ attr_accessor :Port, :InstanceId, :Weight, :ProbePort
32
+
33
+ def initialize(port=nil, instanceid=nil, weight=nil, probeport=nil)
34
+ @Port = port
35
+ @InstanceId = instanceid
36
+ @Weight = weight
37
+ @ProbePort = probeport
38
+ end
39
+
40
+ def deserialize(params)
41
+ @Port = params['Port']
42
+ @InstanceId = params['InstanceId']
43
+ @Weight = params['Weight']
44
+ @ProbePort = params['ProbePort']
45
+ end
46
+ end
47
+
48
+ # BindL4Backends请求参数结构体
49
+ class BindL4BackendsRequest < TencentCloud::Common::AbstractModel
50
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
51
+ # @type LoadBalancerId: String
52
+ # @param ListenerId: 四层监听器实例ID,可通过接口DescribeL4Listeners查询。
53
+ # @type ListenerId: String
54
+ # @param BackendSet: 待绑定的主机信息。可以绑定多个主机端口。目前一个四层监听器下面最多允许绑定255个主机端口。
55
+ # @type BackendSet: Array
56
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
57
+ # @type BindType: Integer
58
+
59
+ attr_accessor :LoadBalancerId, :ListenerId, :BackendSet, :BindType
60
+
61
+ def initialize(loadbalancerid=nil, listenerid=nil, backendset=nil, bindtype=nil)
62
+ @LoadBalancerId = loadbalancerid
63
+ @ListenerId = listenerid
64
+ @BackendSet = backendset
65
+ @BindType = bindtype
66
+ end
67
+
68
+ def deserialize(params)
69
+ @LoadBalancerId = params['LoadBalancerId']
70
+ @ListenerId = params['ListenerId']
71
+ unless params['BackendSet'].nil?
72
+ @BackendSet = []
73
+ params['BackendSet'].each do |i|
74
+ bindl4backend_tmp = BindL4Backend.new
75
+ bindl4backend_tmp.deserialize(i)
76
+ @BackendSet << bindl4backend_tmp
77
+ end
78
+ end
79
+ @BindType = params['BindType']
80
+ end
81
+ end
82
+
83
+ # BindL4Backends返回参数结构体
84
+ class BindL4BackendsResponse < TencentCloud::Common::AbstractModel
85
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
86
+ # @type TaskId: String
87
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
88
+ # @type RequestId: String
89
+
90
+ attr_accessor :TaskId, :RequestId
91
+
92
+ def initialize(taskid=nil, requestid=nil)
93
+ @TaskId = taskid
94
+ @RequestId = requestid
95
+ end
96
+
97
+ def deserialize(params)
98
+ @TaskId = params['TaskId']
99
+ @RequestId = params['RequestId']
100
+ end
101
+ end
102
+
103
+ # 待与七层监听器转发规则绑定的物理机主机、虚拟机或半托管主机信息。目前一个七层转发路径下面最多允许绑定255个主机端口。
104
+ class BindL7Backend < TencentCloud::Common::AbstractModel
105
+ # @param Port: 待绑定的主机端口,可选值1~65535。
106
+ # @type Port: Integer
107
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
108
+ # @type InstanceId: String
109
+ # @param Weight: 待绑定的主机权重,可选值0~100。
110
+ # @type Weight: Integer
111
+
112
+ attr_accessor :Port, :InstanceId, :Weight
113
+
114
+ def initialize(port=nil, instanceid=nil, weight=nil)
115
+ @Port = port
116
+ @InstanceId = instanceid
117
+ @Weight = weight
118
+ end
119
+
120
+ def deserialize(params)
121
+ @Port = params['Port']
122
+ @InstanceId = params['InstanceId']
123
+ @Weight = params['Weight']
124
+ end
125
+ end
126
+
127
+ # BindL7Backends请求参数结构体
128
+ class BindL7BackendsRequest < TencentCloud::Common::AbstractModel
129
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
130
+ # @type LoadBalancerId: String
131
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
132
+ # @type ListenerId: String
133
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
134
+ # @type DomainId: String
135
+ # @param LocationId: 转发路径实例ID,可通过接口DescribeL7Rules查询。
136
+ # @type LocationId: String
137
+ # @param BackendSet: 待绑定的主机信息。可以绑定多个主机端口。目前一个七层转发路径下面最多允许绑定255个主机端口。
138
+ # @type BackendSet: Array
139
+ # @param BindType: 绑定类型。0:物理机,1:虚拟机 2:半托管机器。
140
+ # @type BindType: Integer
141
+
142
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainId, :LocationId, :BackendSet, :BindType
143
+
144
+ def initialize(loadbalancerid=nil, listenerid=nil, domainid=nil, locationid=nil, backendset=nil, bindtype=nil)
145
+ @LoadBalancerId = loadbalancerid
146
+ @ListenerId = listenerid
147
+ @DomainId = domainid
148
+ @LocationId = locationid
149
+ @BackendSet = backendset
150
+ @BindType = bindtype
151
+ end
152
+
153
+ def deserialize(params)
154
+ @LoadBalancerId = params['LoadBalancerId']
155
+ @ListenerId = params['ListenerId']
156
+ @DomainId = params['DomainId']
157
+ @LocationId = params['LocationId']
158
+ unless params['BackendSet'].nil?
159
+ @BackendSet = []
160
+ params['BackendSet'].each do |i|
161
+ bindl7backend_tmp = BindL7Backend.new
162
+ bindl7backend_tmp.deserialize(i)
163
+ @BackendSet << bindl7backend_tmp
164
+ end
165
+ end
166
+ @BindType = params['BindType']
167
+ end
168
+ end
169
+
170
+ # BindL7Backends返回参数结构体
171
+ class BindL7BackendsResponse < TencentCloud::Common::AbstractModel
172
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
173
+ # @type TaskId: String
174
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
175
+ # @type RequestId: String
176
+
177
+ attr_accessor :TaskId, :RequestId
178
+
179
+ def initialize(taskid=nil, requestid=nil)
180
+ @TaskId = taskid
181
+ @RequestId = requestid
182
+ end
183
+
184
+ def deserialize(params)
185
+ @TaskId = params['TaskId']
186
+ @RequestId = params['RequestId']
187
+ end
188
+ end
189
+
190
+ # BindTrafficMirrorListeners请求参数结构体
191
+ class BindTrafficMirrorListenersRequest < TencentCloud::Common::AbstractModel
192
+ # @param TrafficMirrorId: 流量镜像实例ID。
193
+ # @type TrafficMirrorId: String
194
+ # @param ListenerIds: 七层监听器实例ID数组,可通过接口DescribeL7Listeners查询。
195
+ # @type ListenerIds: Array
196
+
197
+ attr_accessor :TrafficMirrorId, :ListenerIds
198
+
199
+ def initialize(trafficmirrorid=nil, listenerids=nil)
200
+ @TrafficMirrorId = trafficmirrorid
201
+ @ListenerIds = listenerids
202
+ end
203
+
204
+ def deserialize(params)
205
+ @TrafficMirrorId = params['TrafficMirrorId']
206
+ @ListenerIds = params['ListenerIds']
207
+ end
208
+ end
209
+
210
+ # BindTrafficMirrorListeners返回参数结构体
211
+ class BindTrafficMirrorListenersResponse < TencentCloud::Common::AbstractModel
212
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
213
+ # @type TaskId: String
214
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
215
+ # @type RequestId: String
216
+
217
+ attr_accessor :TaskId, :RequestId
218
+
219
+ def initialize(taskid=nil, requestid=nil)
220
+ @TaskId = taskid
221
+ @RequestId = requestid
222
+ end
223
+
224
+ def deserialize(params)
225
+ @TaskId = params['TaskId']
226
+ @RequestId = params['RequestId']
227
+ end
228
+ end
229
+
230
+ # 待与流量镜像绑定的接收机信息。
231
+ class BindTrafficMirrorReceiver < TencentCloud::Common::AbstractModel
232
+ # @param Port: 待绑定的主机端口,可选值1~65535。
233
+ # @type Port: Integer
234
+ # @param InstanceId: 待绑定的主机实例ID。
235
+ # @type InstanceId: String
236
+ # @param Weight: 待绑定的主机权重,可选值0~100。
237
+ # @type Weight: Integer
238
+
239
+ attr_accessor :Port, :InstanceId, :Weight
240
+
241
+ def initialize(port=nil, instanceid=nil, weight=nil)
242
+ @Port = port
243
+ @InstanceId = instanceid
244
+ @Weight = weight
245
+ end
246
+
247
+ def deserialize(params)
248
+ @Port = params['Port']
249
+ @InstanceId = params['InstanceId']
250
+ @Weight = params['Weight']
251
+ end
252
+ end
253
+
254
+ # BindTrafficMirrorReceivers请求参数结构体
255
+ class BindTrafficMirrorReceiversRequest < TencentCloud::Common::AbstractModel
256
+ # @param TrafficMirrorId: 流量镜像实例ID。
257
+ # @type TrafficMirrorId: String
258
+ # @param ReceiverSet: 待绑定的黑石物理机信息数组。
259
+ # @type ReceiverSet: Array
260
+
261
+ attr_accessor :TrafficMirrorId, :ReceiverSet
262
+
263
+ def initialize(trafficmirrorid=nil, receiverset=nil)
264
+ @TrafficMirrorId = trafficmirrorid
265
+ @ReceiverSet = receiverset
266
+ end
267
+
268
+ def deserialize(params)
269
+ @TrafficMirrorId = params['TrafficMirrorId']
270
+ unless params['ReceiverSet'].nil?
271
+ @ReceiverSet = []
272
+ params['ReceiverSet'].each do |i|
273
+ bindtrafficmirrorreceiver_tmp = BindTrafficMirrorReceiver.new
274
+ bindtrafficmirrorreceiver_tmp.deserialize(i)
275
+ @ReceiverSet << bindtrafficmirrorreceiver_tmp
276
+ end
277
+ end
278
+ end
279
+ end
280
+
281
+ # BindTrafficMirrorReceivers返回参数结构体
282
+ class BindTrafficMirrorReceiversResponse < TencentCloud::Common::AbstractModel
283
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
284
+ # @type TaskId: String
285
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
286
+ # @type RequestId: String
287
+
288
+ attr_accessor :TaskId, :RequestId
289
+
290
+ def initialize(taskid=nil, requestid=nil)
291
+ @TaskId = taskid
292
+ @RequestId = requestid
293
+ end
294
+
295
+ def deserialize(params)
296
+ @TaskId = params['TaskId']
297
+ @RequestId = params['RequestId']
298
+ end
299
+ end
300
+
301
+ # 获取证书信息时返回的所用在的负载均衡信息。
302
+ class CertDetailLoadBalancer < TencentCloud::Common::AbstractModel
303
+ # @param LoadBalancerId: 黑石负载均衡实例ID。
304
+ # @type LoadBalancerId: String
305
+ # @param LoadBalancerName: 黑石负载均衡实例名称。
306
+ # @type LoadBalancerName: String
307
+ # @param VpcId: 该黑石负载均衡所在的VpcId。
308
+ # @type VpcId: String
309
+ # @param RegionId: 该黑石负载均衡所在的regionId。
310
+ # @type RegionId: Integer
311
+
312
+ attr_accessor :LoadBalancerId, :LoadBalancerName, :VpcId, :RegionId
313
+
314
+ def initialize(loadbalancerid=nil, loadbalancername=nil, vpcid=nil, regionid=nil)
315
+ @LoadBalancerId = loadbalancerid
316
+ @LoadBalancerName = loadbalancername
317
+ @VpcId = vpcid
318
+ @RegionId = regionid
319
+ end
320
+
321
+ def deserialize(params)
322
+ @LoadBalancerId = params['LoadBalancerId']
323
+ @LoadBalancerName = params['LoadBalancerName']
324
+ @VpcId = params['VpcId']
325
+ @RegionId = params['RegionId']
326
+ end
327
+ end
328
+
329
+ # 用于创建四层监听器的监听器信息。目前一个负载均衡下面最多允许创建50个监听器。
330
+ class CreateL4Listener < TencentCloud::Common::AbstractModel
331
+ # @param LoadBalancerPort: 监听器监听端口,可选值1~65535。
332
+ # @type LoadBalancerPort: Integer
333
+ # @param Protocol: 监听器协议类型,可选值tcp,udp。
334
+ # @type Protocol: String
335
+ # @param ListenerName: 监听器名称。
336
+ # @type ListenerName: String
337
+ # @param SessionExpire: 监听器的会话保持时间,单位:秒。可选值:900~3600,不传表示不开启会话保持。
338
+ # @type SessionExpire: Integer
339
+ # @param HealthSwitch: 是否开启健康检查:1(开启)、0(关闭)。默认值0,表示关闭。
340
+ # @type HealthSwitch: Integer
341
+ # @param TimeOut: 健康检查的响应超时时间,可选值:2-60,默认值:2,单位:秒。<br><font color="red">响应超时时间要小于检查间隔时间。</font>
342
+ # @type TimeOut: Integer
343
+ # @param IntervalTime: 健康检查检查间隔时间,默认值:5,可选值:5-300,单位:秒。
344
+ # @type IntervalTime: Integer
345
+ # @param HealthNum: 健康阈值,默认值:3,表示当连续探测三次健康则表示该转发正常,可选值:2-10,单位:次。
346
+ # @type HealthNum: Integer
347
+ # @param UnhealthNum: 不健康阈值,默认值:3,表示当连续探测三次不健康则表示该转发不正常,可选值:2-10,单位:次。
348
+ # @type UnhealthNum: Integer
349
+ # @param Bandwidth: 监听器最大带宽值,用于计费模式为固定带宽计费,可选值:0-1000,单位:Mbps。
350
+ # @type Bandwidth: Integer
351
+ # @param CustomHealthSwitch: 是否开启自定义健康检查:1(开启)、0(关闭)。默认值0,表示关闭。(该字段在健康检查开启的情况下才生效)
352
+ # @type CustomHealthSwitch: Integer
353
+ # @param InputType: 自定义健康探测内容类型,可选值:text(文本)、hexadecimal(十六进制)。
354
+ # @type InputType: String
355
+ # @param LineSeparatorType: 探测内容类型为文本方式时,针对请求文本中换行替换方式。可选值:1(替换为LF)、2(替换为CR)、3(替换为LF+CR)。
356
+ # @type LineSeparatorType: Integer
357
+ # @param HealthRequest: 自定义探测请求内容。
358
+ # @type HealthRequest: String
359
+ # @param HealthResponse: 自定义探测返回内容。
360
+ # @type HealthResponse: String
361
+ # @param ToaFlag: 是否开启toa。可选值:0(关闭)、1(开启),默认关闭。(该字段在负载均衡为fullnat类型下才生效)
362
+ # @type ToaFlag: Integer
363
+
364
+ attr_accessor :LoadBalancerPort, :Protocol, :ListenerName, :SessionExpire, :HealthSwitch, :TimeOut, :IntervalTime, :HealthNum, :UnhealthNum, :Bandwidth, :CustomHealthSwitch, :InputType, :LineSeparatorType, :HealthRequest, :HealthResponse, :ToaFlag
365
+
366
+ def initialize(loadbalancerport=nil, protocol=nil, listenername=nil, sessionexpire=nil, healthswitch=nil, timeout=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, bandwidth=nil, customhealthswitch=nil, inputtype=nil, lineseparatortype=nil, healthrequest=nil, healthresponse=nil, toaflag=nil)
367
+ @LoadBalancerPort = loadbalancerport
368
+ @Protocol = protocol
369
+ @ListenerName = listenername
370
+ @SessionExpire = sessionexpire
371
+ @HealthSwitch = healthswitch
372
+ @TimeOut = timeout
373
+ @IntervalTime = intervaltime
374
+ @HealthNum = healthnum
375
+ @UnhealthNum = unhealthnum
376
+ @Bandwidth = bandwidth
377
+ @CustomHealthSwitch = customhealthswitch
378
+ @InputType = inputtype
379
+ @LineSeparatorType = lineseparatortype
380
+ @HealthRequest = healthrequest
381
+ @HealthResponse = healthresponse
382
+ @ToaFlag = toaflag
383
+ end
384
+
385
+ def deserialize(params)
386
+ @LoadBalancerPort = params['LoadBalancerPort']
387
+ @Protocol = params['Protocol']
388
+ @ListenerName = params['ListenerName']
389
+ @SessionExpire = params['SessionExpire']
390
+ @HealthSwitch = params['HealthSwitch']
391
+ @TimeOut = params['TimeOut']
392
+ @IntervalTime = params['IntervalTime']
393
+ @HealthNum = params['HealthNum']
394
+ @UnhealthNum = params['UnhealthNum']
395
+ @Bandwidth = params['Bandwidth']
396
+ @CustomHealthSwitch = params['CustomHealthSwitch']
397
+ @InputType = params['InputType']
398
+ @LineSeparatorType = params['LineSeparatorType']
399
+ @HealthRequest = params['HealthRequest']
400
+ @HealthResponse = params['HealthResponse']
401
+ @ToaFlag = params['ToaFlag']
402
+ end
403
+ end
404
+
405
+ # CreateL4Listeners请求参数结构体
406
+ class CreateL4ListenersRequest < TencentCloud::Common::AbstractModel
407
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
408
+ # @type LoadBalancerId: String
409
+ # @param ListenerSet: 监听器信息数组,可以创建多个监听器。目前一个负载均衡下面最多允许创建50个监听器
410
+ # @type ListenerSet: Array
411
+
412
+ attr_accessor :LoadBalancerId, :ListenerSet
413
+
414
+ def initialize(loadbalancerid=nil, listenerset=nil)
415
+ @LoadBalancerId = loadbalancerid
416
+ @ListenerSet = listenerset
417
+ end
418
+
419
+ def deserialize(params)
420
+ @LoadBalancerId = params['LoadBalancerId']
421
+ unless params['ListenerSet'].nil?
422
+ @ListenerSet = []
423
+ params['ListenerSet'].each do |i|
424
+ createl4listener_tmp = CreateL4Listener.new
425
+ createl4listener_tmp.deserialize(i)
426
+ @ListenerSet << createl4listener_tmp
427
+ end
428
+ end
429
+ end
430
+ end
431
+
432
+ # CreateL4Listeners返回参数结构体
433
+ class CreateL4ListenersResponse < TencentCloud::Common::AbstractModel
434
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果
435
+ # @type TaskId: String
436
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
437
+ # @type RequestId: String
438
+
439
+ attr_accessor :TaskId, :RequestId
440
+
441
+ def initialize(taskid=nil, requestid=nil)
442
+ @TaskId = taskid
443
+ @RequestId = requestid
444
+ end
445
+
446
+ def deserialize(params)
447
+ @TaskId = params['TaskId']
448
+ @RequestId = params['RequestId']
449
+ end
450
+ end
451
+
452
+ # 用于创建四层监听器的监听器信息。目前一个负载均衡下面最多允许创建50个七层监听器。
453
+ class CreateL7Listener < TencentCloud::Common::AbstractModel
454
+ # @param LoadBalancerPort: 七层监听器端口,可选值1~65535。
455
+ # @type LoadBalancerPort: Integer
456
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
457
+ # @type Protocol: String
458
+ # @param ListenerName: 七层监听器名称。
459
+ # @type ListenerName: String
460
+ # @param SslMode: 认证方式:0(不认证,用于http),1(单向认证,用于https),2(双向认证,用于https)。当创建的是https类型的监听器时,此值必选。
461
+ # @type SslMode: Integer
462
+ # @param CertId: 服务端证书ID。当创建的是https类型的监听器时,此值必选。
463
+ # @type CertId: String
464
+ # @param CertName: 服务端证书名称。
465
+ # @type CertName: String
466
+ # @param CertContent: 服务端证书内容。
467
+ # @type CertContent: String
468
+ # @param CertKey: 服务端证书密钥。
469
+ # @type CertKey: String
470
+ # @param CertCaId: 客户端证书ID。
471
+ # @type CertCaId: String
472
+ # @param CertCaName: 客户端证书名称。
473
+ # @type CertCaName: String
474
+ # @param CertCaContent: 客户端证书内容。
475
+ # @type CertCaContent: String
476
+ # @param Bandwidth: 用于计费模式为固定带宽计费,指定监听器最大带宽值,可选值:0-1000,单位:Mbps。
477
+ # @type Bandwidth: Integer
478
+ # @param ForwardProtocol: 转发协议。当Protocol为https时并且SslMode为1或2时,有意义。可选的值为0:https,1:spdy,2:http2,3:spdy+http2。
479
+ # @type ForwardProtocol: Integer
480
+
481
+ attr_accessor :LoadBalancerPort, :Protocol, :ListenerName, :SslMode, :CertId, :CertName, :CertContent, :CertKey, :CertCaId, :CertCaName, :CertCaContent, :Bandwidth, :ForwardProtocol
482
+
483
+ def initialize(loadbalancerport=nil, protocol=nil, listenername=nil, sslmode=nil, certid=nil, certname=nil, certcontent=nil, certkey=nil, certcaid=nil, certcaname=nil, certcacontent=nil, bandwidth=nil, forwardprotocol=nil)
484
+ @LoadBalancerPort = loadbalancerport
485
+ @Protocol = protocol
486
+ @ListenerName = listenername
487
+ @SslMode = sslmode
488
+ @CertId = certid
489
+ @CertName = certname
490
+ @CertContent = certcontent
491
+ @CertKey = certkey
492
+ @CertCaId = certcaid
493
+ @CertCaName = certcaname
494
+ @CertCaContent = certcacontent
495
+ @Bandwidth = bandwidth
496
+ @ForwardProtocol = forwardprotocol
497
+ end
498
+
499
+ def deserialize(params)
500
+ @LoadBalancerPort = params['LoadBalancerPort']
501
+ @Protocol = params['Protocol']
502
+ @ListenerName = params['ListenerName']
503
+ @SslMode = params['SslMode']
504
+ @CertId = params['CertId']
505
+ @CertName = params['CertName']
506
+ @CertContent = params['CertContent']
507
+ @CertKey = params['CertKey']
508
+ @CertCaId = params['CertCaId']
509
+ @CertCaName = params['CertCaName']
510
+ @CertCaContent = params['CertCaContent']
511
+ @Bandwidth = params['Bandwidth']
512
+ @ForwardProtocol = params['ForwardProtocol']
513
+ end
514
+ end
515
+
516
+ # CreateL7Listeners请求参数结构体
517
+ class CreateL7ListenersRequest < TencentCloud::Common::AbstractModel
518
+ # @param LoadBalancerId: 负载均衡实例ID
519
+ # @type LoadBalancerId: String
520
+ # @param ListenerSet: 七层监听器信息数组,可以创建多个七层监听器。目前一个负载均衡下面最多允许创建50个七层监听器。
521
+ # @type ListenerSet: Array
522
+
523
+ attr_accessor :LoadBalancerId, :ListenerSet
524
+
525
+ def initialize(loadbalancerid=nil, listenerset=nil)
526
+ @LoadBalancerId = loadbalancerid
527
+ @ListenerSet = listenerset
528
+ end
529
+
530
+ def deserialize(params)
531
+ @LoadBalancerId = params['LoadBalancerId']
532
+ unless params['ListenerSet'].nil?
533
+ @ListenerSet = []
534
+ params['ListenerSet'].each do |i|
535
+ createl7listener_tmp = CreateL7Listener.new
536
+ createl7listener_tmp.deserialize(i)
537
+ @ListenerSet << createl7listener_tmp
538
+ end
539
+ end
540
+ end
541
+ end
542
+
543
+ # CreateL7Listeners返回参数结构体
544
+ class CreateL7ListenersResponse < TencentCloud::Common::AbstractModel
545
+ # @param ListenerIds: 新建的负载均衡七层监听器的唯一ID列表。
546
+ # @type ListenerIds: Array
547
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
548
+ # @type RequestId: String
549
+
550
+ attr_accessor :ListenerIds, :RequestId
551
+
552
+ def initialize(listenerids=nil, requestid=nil)
553
+ @ListenerIds = listenerids
554
+ @RequestId = requestid
555
+ end
556
+
557
+ def deserialize(params)
558
+ @ListenerIds = params['ListenerIds']
559
+ @RequestId = params['RequestId']
560
+ end
561
+ end
562
+
563
+ # 用于创建七层监听器的转发规则的信息。目前一个七层监听器下面最多允许创建50个七层转发域名,而每一个转发域名下最多可以创建100个转发规则。
564
+ class CreateL7Rule < TencentCloud::Common::AbstractModel
565
+ # @param Domain: 七层转发规则的转发域名。
566
+ # @type Domain: String
567
+ # @param Url: 七层转发规则的转发路径。
568
+ # @type Url: String
569
+ # @param SessionExpire: 会话保持时间,单位:秒。可选值:30~3600。默认值0,表示不开启会话保持。
570
+ # @type SessionExpire: Integer
571
+ # @param HealthSwitch: 健康检查开关:1(开启)、0(关闭)。默认值0,表示关闭。
572
+ # @type HealthSwitch: Integer
573
+ # @param IntervalTime: 健康检查检查间隔时间,默认值:5,可选值:5-300,单位:秒。
574
+ # @type IntervalTime: Integer
575
+ # @param HealthNum: 健康检查健康阈值,默认值:3,表示当连续探测三次健康则表示该转发正常,可选值:2-10,单位:次。
576
+ # @type HealthNum: Integer
577
+ # @param UnhealthNum: 健康检查不健康阈值,默认值:5,表示当连续探测五次不健康则表示该转发不正常,可选值:2-10,单位:次。
578
+ # @type UnhealthNum: Integer
579
+ # @param HttpCodes: 健康检查中认为健康的HTTP返回码的组合。可选值为1~5的集合,1表示HTTP返回码为1xx认为健康。2表示HTTP返回码为2xx认为健康。3表示HTTP返回码为3xx认为健康。4表示HTTP返回码为4xx认为健康。5表示HTTP返回码为5xx认为健康。
580
+ # @type HttpCodes: Array
581
+ # @param HttpCheckPath: 健康检查检查路径。
582
+ # @type HttpCheckPath: String
583
+ # @param HttpCheckDomain: 健康检查检查域名。如果创建规则的域名使用通配符或正则表达式,则健康检查检查域名可自定义,否则必须跟健康检查检查域名一样。
584
+ # @type HttpCheckDomain: String
585
+ # @param BalanceMode: 均衡方式:ip_hash、wrr。默认值wrr。
586
+ # @type BalanceMode: String
587
+
588
+ attr_accessor :Domain, :Url, :SessionExpire, :HealthSwitch, :IntervalTime, :HealthNum, :UnhealthNum, :HttpCodes, :HttpCheckPath, :HttpCheckDomain, :BalanceMode
589
+
590
+ def initialize(domain=nil, url=nil, sessionexpire=nil, healthswitch=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, httpcodes=nil, httpcheckpath=nil, httpcheckdomain=nil, balancemode=nil)
591
+ @Domain = domain
592
+ @Url = url
593
+ @SessionExpire = sessionexpire
594
+ @HealthSwitch = healthswitch
595
+ @IntervalTime = intervaltime
596
+ @HealthNum = healthnum
597
+ @UnhealthNum = unhealthnum
598
+ @HttpCodes = httpcodes
599
+ @HttpCheckPath = httpcheckpath
600
+ @HttpCheckDomain = httpcheckdomain
601
+ @BalanceMode = balancemode
602
+ end
603
+
604
+ def deserialize(params)
605
+ @Domain = params['Domain']
606
+ @Url = params['Url']
607
+ @SessionExpire = params['SessionExpire']
608
+ @HealthSwitch = params['HealthSwitch']
609
+ @IntervalTime = params['IntervalTime']
610
+ @HealthNum = params['HealthNum']
611
+ @UnhealthNum = params['UnhealthNum']
612
+ @HttpCodes = params['HttpCodes']
613
+ @HttpCheckPath = params['HttpCheckPath']
614
+ @HttpCheckDomain = params['HttpCheckDomain']
615
+ @BalanceMode = params['BalanceMode']
616
+ end
617
+ end
618
+
619
+ # CreateL7Rules请求参数结构体
620
+ class CreateL7RulesRequest < TencentCloud::Common::AbstractModel
621
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
622
+ # @type LoadBalancerId: String
623
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
624
+ # @type ListenerId: String
625
+ # @param RuleSet: 七层转发规则信息数组,可以创建多个七层转发规则。目前一个七层监听器下面最多允许创建50个七层转发域名,而每一个转发域名下最多可以创建100个转发规则。目前只能单条创建,不能批量创建。
626
+ # @type RuleSet: Array
627
+
628
+ attr_accessor :LoadBalancerId, :ListenerId, :RuleSet
629
+
630
+ def initialize(loadbalancerid=nil, listenerid=nil, ruleset=nil)
631
+ @LoadBalancerId = loadbalancerid
632
+ @ListenerId = listenerid
633
+ @RuleSet = ruleset
634
+ end
635
+
636
+ def deserialize(params)
637
+ @LoadBalancerId = params['LoadBalancerId']
638
+ @ListenerId = params['ListenerId']
639
+ unless params['RuleSet'].nil?
640
+ @RuleSet = []
641
+ params['RuleSet'].each do |i|
642
+ createl7rule_tmp = CreateL7Rule.new
643
+ createl7rule_tmp.deserialize(i)
644
+ @RuleSet << createl7rule_tmp
645
+ end
646
+ end
647
+ end
648
+ end
649
+
650
+ # CreateL7Rules返回参数结构体
651
+ class CreateL7RulesResponse < TencentCloud::Common::AbstractModel
652
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
653
+ # @type TaskId: String
654
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
655
+ # @type RequestId: String
656
+
657
+ attr_accessor :TaskId, :RequestId
658
+
659
+ def initialize(taskid=nil, requestid=nil)
660
+ @TaskId = taskid
661
+ @RequestId = requestid
662
+ end
663
+
664
+ def deserialize(params)
665
+ @TaskId = params['TaskId']
666
+ @RequestId = params['RequestId']
667
+ end
668
+ end
669
+
670
+ # 用于创建负载均衡的个性化配置。
671
+ class CreateLoadBalancerBzConf < TencentCloud::Common::AbstractModel
672
+ # @param BzPayMode: 按月/按小时计费。
673
+ # @type BzPayMode: String
674
+ # @param BzL4Metrics: 四层可选按带宽,连接数衡量。
675
+ # @type BzL4Metrics: String
676
+ # @param BzL7Metrics: 七层可选按qps衡量。
677
+ # @type BzL7Metrics: String
678
+
679
+ attr_accessor :BzPayMode, :BzL4Metrics, :BzL7Metrics
680
+
681
+ def initialize(bzpaymode=nil, bzl4metrics=nil, bzl7metrics=nil)
682
+ @BzPayMode = bzpaymode
683
+ @BzL4Metrics = bzl4metrics
684
+ @BzL7Metrics = bzl7metrics
685
+ end
686
+
687
+ def deserialize(params)
688
+ @BzPayMode = params['BzPayMode']
689
+ @BzL4Metrics = params['BzL4Metrics']
690
+ @BzL7Metrics = params['BzL7Metrics']
691
+ end
692
+ end
693
+
694
+ # CreateLoadBalancers请求参数结构体
695
+ class CreateLoadBalancersRequest < TencentCloud::Common::AbstractModel
696
+ # @param VpcId: 黑石负载均衡实例所属的私有网络ID。
697
+ # @type VpcId: String
698
+ # @param LoadBalancerType: 负载均衡的类型,取值为open或internal。open表示公网(有日租),internal表示内网。
699
+ # @type LoadBalancerType: String
700
+ # @param SubnetId: 在私有网络内购买内网负载均衡实例的时候需要指定子网ID,内网负载均衡实例的VIP将从这个子网中产生。其他情况不用填写该字段。
701
+ # @type SubnetId: String
702
+ # @param ProjectId: 负载均衡所属项目ID。不填则属于默认项目。
703
+ # @type ProjectId: Integer
704
+ # @param GoodsNum: 购买黑石负载均衡实例的数量。默认值为1, 最大值为20。
705
+ # @type GoodsNum: Integer
706
+ # @param PayMode: 黑石负载均衡的计费模式,取值为flow和bandwidth,其中flow模式表示流量模式,bandwidth表示带宽模式。默认值为flow。
707
+ # @type PayMode: String
708
+ # @param TgwSetType: 负载均衡对应的TGW集群类别,取值为tunnel、fullnat或dnat。tunnel表示隧道集群,fullnat表示FULLNAT集群(普通外网负载均衡),dnat表示DNAT集群(增强型外网负载均衡)。默认值为fullnat。如需获取client IP,可以选择 tunnel 模式,fullnat 模式(tcp 通过toa 获取),dnat 模式。
709
+ # @type TgwSetType: String
710
+ # @param Exclusive: 负载均衡的独占类别,取值为0表示非独占,1表示四层独占,2表示七层独占,3表示四层和七层独占,4表示共享容灾。
711
+ # @type Exclusive: Integer
712
+ # @param SpecifiedVips: 指定的VIP,如果指定,则数量必须与goodsNum一致。如果不指定,则由后台分配随机VIP。
713
+ # @type SpecifiedVips: Array
714
+ # @param BzConf: (未全地域开放)保障型负载均衡设定参数,如果类别选择保障型则需传入此参数。
715
+ # @type BzConf: :class:`Tencentcloud::Bmlb.v20180625.models.CreateLoadBalancerBzConf`
716
+ # @param IpProtocolType: IP协议类型。可取的值为“ipv4”或“ipv6”。
717
+ # @type IpProtocolType: String
718
+
719
+ attr_accessor :VpcId, :LoadBalancerType, :SubnetId, :ProjectId, :GoodsNum, :PayMode, :TgwSetType, :Exclusive, :SpecifiedVips, :BzConf, :IpProtocolType
720
+
721
+ def initialize(vpcid=nil, loadbalancertype=nil, subnetid=nil, projectid=nil, goodsnum=nil, paymode=nil, tgwsettype=nil, exclusive=nil, specifiedvips=nil, bzconf=nil, ipprotocoltype=nil)
722
+ @VpcId = vpcid
723
+ @LoadBalancerType = loadbalancertype
724
+ @SubnetId = subnetid
725
+ @ProjectId = projectid
726
+ @GoodsNum = goodsnum
727
+ @PayMode = paymode
728
+ @TgwSetType = tgwsettype
729
+ @Exclusive = exclusive
730
+ @SpecifiedVips = specifiedvips
731
+ @BzConf = bzconf
732
+ @IpProtocolType = ipprotocoltype
733
+ end
734
+
735
+ def deserialize(params)
736
+ @VpcId = params['VpcId']
737
+ @LoadBalancerType = params['LoadBalancerType']
738
+ @SubnetId = params['SubnetId']
739
+ @ProjectId = params['ProjectId']
740
+ @GoodsNum = params['GoodsNum']
741
+ @PayMode = params['PayMode']
742
+ @TgwSetType = params['TgwSetType']
743
+ @Exclusive = params['Exclusive']
744
+ @SpecifiedVips = params['SpecifiedVips']
745
+ unless params['BzConf'].nil?
746
+ @BzConf = CreateLoadBalancerBzConf.new
747
+ @BzConf.deserialize(params['BzConf'])
748
+ end
749
+ @IpProtocolType = params['IpProtocolType']
750
+ end
751
+ end
752
+
753
+ # CreateLoadBalancers返回参数结构体
754
+ class CreateLoadBalancersResponse < TencentCloud::Common::AbstractModel
755
+ # @param LoadBalancerIds: 创建的黑石负载均衡实例ID。
756
+ # @type LoadBalancerIds: Array
757
+ # @param TaskId: 创建负载均衡的异步任务ID。
758
+ # @type TaskId: String
759
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
760
+ # @type RequestId: String
761
+
762
+ attr_accessor :LoadBalancerIds, :TaskId, :RequestId
763
+
764
+ def initialize(loadbalancerids=nil, taskid=nil, requestid=nil)
765
+ @LoadBalancerIds = loadbalancerids
766
+ @TaskId = taskid
767
+ @RequestId = requestid
768
+ end
769
+
770
+ def deserialize(params)
771
+ @LoadBalancerIds = params['LoadBalancerIds']
772
+ @TaskId = params['TaskId']
773
+ @RequestId = params['RequestId']
774
+ end
775
+ end
776
+
777
+ # CreateTrafficMirror请求参数结构体
778
+ class CreateTrafficMirrorRequest < TencentCloud::Common::AbstractModel
779
+ # @param Alias: 流量镜像实例别名。
780
+ # @type Alias: String
781
+ # @param VpcId: 流量镜像实例所属的私有网络ID,形如:vpc-xxx。
782
+ # @type VpcId: String
783
+
784
+ attr_accessor :Alias, :VpcId
785
+
786
+ def initialize(_alias=nil, vpcid=nil)
787
+ @Alias = _alias
788
+ @VpcId = vpcid
789
+ end
790
+
791
+ def deserialize(params)
792
+ @Alias = params['Alias']
793
+ @VpcId = params['VpcId']
794
+ end
795
+ end
796
+
797
+ # CreateTrafficMirror返回参数结构体
798
+ class CreateTrafficMirrorResponse < TencentCloud::Common::AbstractModel
799
+ # @param TrafficMirrorId: 流量镜像实例ID
800
+ # @type TrafficMirrorId: String
801
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
802
+ # @type RequestId: String
803
+
804
+ attr_accessor :TrafficMirrorId, :RequestId
805
+
806
+ def initialize(trafficmirrorid=nil, requestid=nil)
807
+ @TrafficMirrorId = trafficmirrorid
808
+ @RequestId = requestid
809
+ end
810
+
811
+ def deserialize(params)
812
+ @TrafficMirrorId = params['TrafficMirrorId']
813
+ @RequestId = params['RequestId']
814
+ end
815
+ end
816
+
817
+ # DeleteL7Domains请求参数结构体
818
+ class DeleteL7DomainsRequest < TencentCloud::Common::AbstractModel
819
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
820
+ # @type LoadBalancerId: String
821
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
822
+ # @type ListenerId: String
823
+ # @param DomainIds: 转发域名实例ID列表,可通过接口DescribeL7Rules查询。
824
+ # @type DomainIds: Array
825
+
826
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainIds
827
+
828
+ def initialize(loadbalancerid=nil, listenerid=nil, domainids=nil)
829
+ @LoadBalancerId = loadbalancerid
830
+ @ListenerId = listenerid
831
+ @DomainIds = domainids
832
+ end
833
+
834
+ def deserialize(params)
835
+ @LoadBalancerId = params['LoadBalancerId']
836
+ @ListenerId = params['ListenerId']
837
+ @DomainIds = params['DomainIds']
838
+ end
839
+ end
840
+
841
+ # DeleteL7Domains返回参数结构体
842
+ class DeleteL7DomainsResponse < TencentCloud::Common::AbstractModel
843
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
844
+ # @type TaskId: String
845
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
846
+ # @type RequestId: String
847
+
848
+ attr_accessor :TaskId, :RequestId
849
+
850
+ def initialize(taskid=nil, requestid=nil)
851
+ @TaskId = taskid
852
+ @RequestId = requestid
853
+ end
854
+
855
+ def deserialize(params)
856
+ @TaskId = params['TaskId']
857
+ @RequestId = params['RequestId']
858
+ end
859
+ end
860
+
861
+ # DeleteL7Rules请求参数结构体
862
+ class DeleteL7RulesRequest < TencentCloud::Common::AbstractModel
863
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
864
+ # @type LoadBalancerId: String
865
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
866
+ # @type ListenerId: String
867
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
868
+ # @type DomainId: String
869
+ # @param LocationIds: 转发路径实例ID列表,可通过接口DescribeL7Rules查询。
870
+ # @type LocationIds: Array
871
+
872
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainId, :LocationIds
873
+
874
+ def initialize(loadbalancerid=nil, listenerid=nil, domainid=nil, locationids=nil)
875
+ @LoadBalancerId = loadbalancerid
876
+ @ListenerId = listenerid
877
+ @DomainId = domainid
878
+ @LocationIds = locationids
879
+ end
880
+
881
+ def deserialize(params)
882
+ @LoadBalancerId = params['LoadBalancerId']
883
+ @ListenerId = params['ListenerId']
884
+ @DomainId = params['DomainId']
885
+ @LocationIds = params['LocationIds']
886
+ end
887
+ end
888
+
889
+ # DeleteL7Rules返回参数结构体
890
+ class DeleteL7RulesResponse < TencentCloud::Common::AbstractModel
891
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
892
+ # @type TaskId: String
893
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
894
+ # @type RequestId: String
895
+
896
+ attr_accessor :TaskId, :RequestId
897
+
898
+ def initialize(taskid=nil, requestid=nil)
899
+ @TaskId = taskid
900
+ @RequestId = requestid
901
+ end
902
+
903
+ def deserialize(params)
904
+ @TaskId = params['TaskId']
905
+ @RequestId = params['RequestId']
906
+ end
907
+ end
908
+
909
+ # DeleteListeners请求参数结构体
910
+ class DeleteListenersRequest < TencentCloud::Common::AbstractModel
911
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
912
+ # @type LoadBalancerId: String
913
+ # @param ListenerIds: 待删除的负载均衡四层和七层监听器ID列表,可通过接口DescribeL4Listeners和DescribeL7Listeners查询。目前同时只能删除一种类型的监听器,并且删除七层监听器的数量上限为一个。
914
+ # @type ListenerIds: Array
915
+
916
+ attr_accessor :LoadBalancerId, :ListenerIds
917
+
918
+ def initialize(loadbalancerid=nil, listenerids=nil)
919
+ @LoadBalancerId = loadbalancerid
920
+ @ListenerIds = listenerids
921
+ end
922
+
923
+ def deserialize(params)
924
+ @LoadBalancerId = params['LoadBalancerId']
925
+ @ListenerIds = params['ListenerIds']
926
+ end
927
+ end
928
+
929
+ # DeleteListeners返回参数结构体
930
+ class DeleteListenersResponse < TencentCloud::Common::AbstractModel
931
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
932
+ # @type TaskId: String
933
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
934
+ # @type RequestId: String
935
+
936
+ attr_accessor :TaskId, :RequestId
937
+
938
+ def initialize(taskid=nil, requestid=nil)
939
+ @TaskId = taskid
940
+ @RequestId = requestid
941
+ end
942
+
943
+ def deserialize(params)
944
+ @TaskId = params['TaskId']
945
+ @RequestId = params['RequestId']
946
+ end
947
+ end
948
+
949
+ # DeleteLoadBalancer请求参数结构体
950
+ class DeleteLoadBalancerRequest < TencentCloud::Common::AbstractModel
951
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
952
+ # @type LoadBalancerId: String
953
+
954
+ attr_accessor :LoadBalancerId
955
+
956
+ def initialize(loadbalancerid=nil)
957
+ @LoadBalancerId = loadbalancerid
958
+ end
959
+
960
+ def deserialize(params)
961
+ @LoadBalancerId = params['LoadBalancerId']
962
+ end
963
+ end
964
+
965
+ # DeleteLoadBalancer返回参数结构体
966
+ class DeleteLoadBalancerResponse < TencentCloud::Common::AbstractModel
967
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
968
+ # @type TaskId: String
969
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
970
+ # @type RequestId: String
971
+
972
+ attr_accessor :TaskId, :RequestId
973
+
974
+ def initialize(taskid=nil, requestid=nil)
975
+ @TaskId = taskid
976
+ @RequestId = requestid
977
+ end
978
+
979
+ def deserialize(params)
980
+ @TaskId = params['TaskId']
981
+ @RequestId = params['RequestId']
982
+ end
983
+ end
984
+
985
+ # DeleteTrafficMirror请求参数结构体
986
+ class DeleteTrafficMirrorRequest < TencentCloud::Common::AbstractModel
987
+ # @param TrafficMirrorIds: 流量镜像实例ID数组,可以批量删除,每次删除上限为20
988
+ # @type TrafficMirrorIds: Array
989
+
990
+ attr_accessor :TrafficMirrorIds
991
+
992
+ def initialize(trafficmirrorids=nil)
993
+ @TrafficMirrorIds = trafficmirrorids
994
+ end
995
+
996
+ def deserialize(params)
997
+ @TrafficMirrorIds = params['TrafficMirrorIds']
998
+ end
999
+ end
1000
+
1001
+ # DeleteTrafficMirror返回参数结构体
1002
+ class DeleteTrafficMirrorResponse < TencentCloud::Common::AbstractModel
1003
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
1004
+ # @type TaskId: String
1005
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1006
+ # @type RequestId: String
1007
+
1008
+ attr_accessor :TaskId, :RequestId
1009
+
1010
+ def initialize(taskid=nil, requestid=nil)
1011
+ @TaskId = taskid
1012
+ @RequestId = requestid
1013
+ end
1014
+
1015
+ def deserialize(params)
1016
+ @TaskId = params['TaskId']
1017
+ @RequestId = params['RequestId']
1018
+ end
1019
+ end
1020
+
1021
+ # DescribeCertDetail请求参数结构体
1022
+ class DescribeCertDetailRequest < TencentCloud::Common::AbstractModel
1023
+ # @param CertId: 证书ID。
1024
+ # @type CertId: String
1025
+
1026
+ attr_accessor :CertId
1027
+
1028
+ def initialize(certid=nil)
1029
+ @CertId = certid
1030
+ end
1031
+
1032
+ def deserialize(params)
1033
+ @CertId = params['CertId']
1034
+ end
1035
+ end
1036
+
1037
+ # DescribeCertDetail返回参数结构体
1038
+ class DescribeCertDetailResponse < TencentCloud::Common::AbstractModel
1039
+ # @param CertId: 证书ID。
1040
+ # @type CertId: String
1041
+ # @param CertName: 证书名称。
1042
+ # @type CertName: String
1043
+ # @param CertType: 证书类型(SVR=服务器证书,CA=客户端证书)。
1044
+ # @type CertType: String
1045
+ # @param CertContent: 证书内容。
1046
+ # @type CertContent: String
1047
+ # @param CertDomain: 证书主域名。
1048
+ # @type CertDomain: String
1049
+ # @param CertSubjectDomain: 证书子域名列表。
1050
+ # @type CertSubjectDomain: Array
1051
+ # @param CertUploadTime: 证书上传时间。
1052
+ # @type CertUploadTime: String
1053
+ # @param CertBeginTime: 证书生效时间。
1054
+ # @type CertBeginTime: String
1055
+ # @param CertEndTime: 证书失效时间。
1056
+ # @type CertEndTime: String
1057
+ # @param CertLoadBalancerSet: 该证书关联的黑石负载均衡对象列表。
1058
+ # @type CertLoadBalancerSet: Array
1059
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1060
+ # @type RequestId: String
1061
+
1062
+ attr_accessor :CertId, :CertName, :CertType, :CertContent, :CertDomain, :CertSubjectDomain, :CertUploadTime, :CertBeginTime, :CertEndTime, :CertLoadBalancerSet, :RequestId
1063
+
1064
+ def initialize(certid=nil, certname=nil, certtype=nil, certcontent=nil, certdomain=nil, certsubjectdomain=nil, certuploadtime=nil, certbegintime=nil, certendtime=nil, certloadbalancerset=nil, requestid=nil)
1065
+ @CertId = certid
1066
+ @CertName = certname
1067
+ @CertType = certtype
1068
+ @CertContent = certcontent
1069
+ @CertDomain = certdomain
1070
+ @CertSubjectDomain = certsubjectdomain
1071
+ @CertUploadTime = certuploadtime
1072
+ @CertBeginTime = certbegintime
1073
+ @CertEndTime = certendtime
1074
+ @CertLoadBalancerSet = certloadbalancerset
1075
+ @RequestId = requestid
1076
+ end
1077
+
1078
+ def deserialize(params)
1079
+ @CertId = params['CertId']
1080
+ @CertName = params['CertName']
1081
+ @CertType = params['CertType']
1082
+ @CertContent = params['CertContent']
1083
+ @CertDomain = params['CertDomain']
1084
+ @CertSubjectDomain = params['CertSubjectDomain']
1085
+ @CertUploadTime = params['CertUploadTime']
1086
+ @CertBeginTime = params['CertBeginTime']
1087
+ @CertEndTime = params['CertEndTime']
1088
+ unless params['CertLoadBalancerSet'].nil?
1089
+ @CertLoadBalancerSet = []
1090
+ params['CertLoadBalancerSet'].each do |i|
1091
+ certdetailloadbalancer_tmp = CertDetailLoadBalancer.new
1092
+ certdetailloadbalancer_tmp.deserialize(i)
1093
+ @CertLoadBalancerSet << certdetailloadbalancer_tmp
1094
+ end
1095
+ end
1096
+ @RequestId = params['RequestId']
1097
+ end
1098
+ end
1099
+
1100
+ # DescribeDevicesBindInfo请求参数结构体
1101
+ class DescribeDevicesBindInfoRequest < TencentCloud::Common::AbstractModel
1102
+ # @param VpcId: 黑石私有网络唯一ID。
1103
+ # @type VpcId: String
1104
+ # @param InstanceIds: 主机ID或虚机IP列表,可用于获取绑定了该主机的负载均衡列表。
1105
+ # @type InstanceIds: Array
1106
+
1107
+ attr_accessor :VpcId, :InstanceIds
1108
+
1109
+ def initialize(vpcid=nil, instanceids=nil)
1110
+ @VpcId = vpcid
1111
+ @InstanceIds = instanceids
1112
+ end
1113
+
1114
+ def deserialize(params)
1115
+ @VpcId = params['VpcId']
1116
+ @InstanceIds = params['InstanceIds']
1117
+ end
1118
+ end
1119
+
1120
+ # DescribeDevicesBindInfo返回参数结构体
1121
+ class DescribeDevicesBindInfoResponse < TencentCloud::Common::AbstractModel
1122
+ # @param LoadBalancerSet: 返回的负载均衡绑定信息。
1123
+ # @type LoadBalancerSet: Array
1124
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1125
+ # @type RequestId: String
1126
+
1127
+ attr_accessor :LoadBalancerSet, :RequestId
1128
+
1129
+ def initialize(loadbalancerset=nil, requestid=nil)
1130
+ @LoadBalancerSet = loadbalancerset
1131
+ @RequestId = requestid
1132
+ end
1133
+
1134
+ def deserialize(params)
1135
+ unless params['LoadBalancerSet'].nil?
1136
+ @LoadBalancerSet = []
1137
+ params['LoadBalancerSet'].each do |i|
1138
+ devicesbindinfoloadbalancer_tmp = DevicesBindInfoLoadBalancer.new
1139
+ devicesbindinfoloadbalancer_tmp.deserialize(i)
1140
+ @LoadBalancerSet << devicesbindinfoloadbalancer_tmp
1141
+ end
1142
+ end
1143
+ @RequestId = params['RequestId']
1144
+ end
1145
+ end
1146
+
1147
+ # 待查询四层监听器绑定的主机信息。
1148
+ class DescribeL4Backend < TencentCloud::Common::AbstractModel
1149
+ # @param Port: 待绑定的主机端口,可选值1~65535。
1150
+ # @type Port: Integer
1151
+ # @param InstanceId: 黑石物理机的主机ID。
1152
+ # @type InstanceId: String
1153
+
1154
+ attr_accessor :Port, :InstanceId
1155
+
1156
+ def initialize(port=nil, instanceid=nil)
1157
+ @Port = port
1158
+ @InstanceId = instanceid
1159
+ end
1160
+
1161
+ def deserialize(params)
1162
+ @Port = params['Port']
1163
+ @InstanceId = params['InstanceId']
1164
+ end
1165
+ end
1166
+
1167
+ # DescribeL4Backends请求参数结构体
1168
+ class DescribeL4BackendsRequest < TencentCloud::Common::AbstractModel
1169
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1170
+ # @type LoadBalancerId: String
1171
+ # @param ListenerId: 负载均衡四层监听器ID,可通过接口DescribeL4Listeners查询。
1172
+ # @type ListenerId: String
1173
+ # @param BackendSet: 待查询的主机信息。
1174
+ # @type BackendSet: Array
1175
+
1176
+ attr_accessor :LoadBalancerId, :ListenerId, :BackendSet
1177
+
1178
+ def initialize(loadbalancerid=nil, listenerid=nil, backendset=nil)
1179
+ @LoadBalancerId = loadbalancerid
1180
+ @ListenerId = listenerid
1181
+ @BackendSet = backendset
1182
+ end
1183
+
1184
+ def deserialize(params)
1185
+ @LoadBalancerId = params['LoadBalancerId']
1186
+ @ListenerId = params['ListenerId']
1187
+ unless params['BackendSet'].nil?
1188
+ @BackendSet = []
1189
+ params['BackendSet'].each do |i|
1190
+ describel4backend_tmp = DescribeL4Backend.new
1191
+ describel4backend_tmp.deserialize(i)
1192
+ @BackendSet << describel4backend_tmp
1193
+ end
1194
+ end
1195
+ end
1196
+ end
1197
+
1198
+ # DescribeL4Backends返回参数结构体
1199
+ class DescribeL4BackendsResponse < TencentCloud::Common::AbstractModel
1200
+ # @param BackendSet: 返回的绑定关系列表。
1201
+ # @type BackendSet: Array
1202
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1203
+ # @type RequestId: String
1204
+
1205
+ attr_accessor :BackendSet, :RequestId
1206
+
1207
+ def initialize(backendset=nil, requestid=nil)
1208
+ @BackendSet = backendset
1209
+ @RequestId = requestid
1210
+ end
1211
+
1212
+ def deserialize(params)
1213
+ unless params['BackendSet'].nil?
1214
+ @BackendSet = []
1215
+ params['BackendSet'].each do |i|
1216
+ l4backend_tmp = L4Backend.new
1217
+ l4backend_tmp.deserialize(i)
1218
+ @BackendSet << l4backend_tmp
1219
+ end
1220
+ end
1221
+ @RequestId = params['RequestId']
1222
+ end
1223
+ end
1224
+
1225
+ # DescribeL4ListenerInfo请求参数结构体
1226
+ class DescribeL4ListenerInfoRequest < TencentCloud::Common::AbstractModel
1227
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1228
+ # @type LoadBalancerId: String
1229
+ # @param SearchKey: 查找的键值,可用于模糊查找该名称的监听器。
1230
+ # @type SearchKey: String
1231
+ # @param InstanceIds: 主机ID或虚机IP列表,可用于获取绑定了该主机的监听器。
1232
+ # @type InstanceIds: Array
1233
+
1234
+ attr_accessor :LoadBalancerId, :SearchKey, :InstanceIds
1235
+
1236
+ def initialize(loadbalancerid=nil, searchkey=nil, instanceids=nil)
1237
+ @LoadBalancerId = loadbalancerid
1238
+ @SearchKey = searchkey
1239
+ @InstanceIds = instanceids
1240
+ end
1241
+
1242
+ def deserialize(params)
1243
+ @LoadBalancerId = params['LoadBalancerId']
1244
+ @SearchKey = params['SearchKey']
1245
+ @InstanceIds = params['InstanceIds']
1246
+ end
1247
+ end
1248
+
1249
+ # DescribeL4ListenerInfo返回参数结构体
1250
+ class DescribeL4ListenerInfoResponse < TencentCloud::Common::AbstractModel
1251
+ # @param ListenerSet: 返回的四层监听器列表。
1252
+ # @type ListenerSet: Array
1253
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1254
+ # @type RequestId: String
1255
+
1256
+ attr_accessor :ListenerSet, :RequestId
1257
+
1258
+ def initialize(listenerset=nil, requestid=nil)
1259
+ @ListenerSet = listenerset
1260
+ @RequestId = requestid
1261
+ end
1262
+
1263
+ def deserialize(params)
1264
+ unless params['ListenerSet'].nil?
1265
+ @ListenerSet = []
1266
+ params['ListenerSet'].each do |i|
1267
+ l4listenerinfo_tmp = L4ListenerInfo.new
1268
+ l4listenerinfo_tmp.deserialize(i)
1269
+ @ListenerSet << l4listenerinfo_tmp
1270
+ end
1271
+ end
1272
+ @RequestId = params['RequestId']
1273
+ end
1274
+ end
1275
+
1276
+ # DescribeL4Listeners请求参数结构体
1277
+ class DescribeL4ListenersRequest < TencentCloud::Common::AbstractModel
1278
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1279
+ # @type LoadBalancerId: String
1280
+ # @param ListenerIds: 四层监听器实例ID数组,可通过接口DescribeL4Listeners查询。
1281
+ # @type ListenerIds: Array
1282
+
1283
+ attr_accessor :LoadBalancerId, :ListenerIds
1284
+
1285
+ def initialize(loadbalancerid=nil, listenerids=nil)
1286
+ @LoadBalancerId = loadbalancerid
1287
+ @ListenerIds = listenerids
1288
+ end
1289
+
1290
+ def deserialize(params)
1291
+ @LoadBalancerId = params['LoadBalancerId']
1292
+ @ListenerIds = params['ListenerIds']
1293
+ end
1294
+ end
1295
+
1296
+ # DescribeL4Listeners返回参数结构体
1297
+ class DescribeL4ListenersResponse < TencentCloud::Common::AbstractModel
1298
+ # @param ListenerSet: 监听器信息数组。
1299
+ # @type ListenerSet: Array
1300
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1301
+ # @type RequestId: String
1302
+
1303
+ attr_accessor :ListenerSet, :RequestId
1304
+
1305
+ def initialize(listenerset=nil, requestid=nil)
1306
+ @ListenerSet = listenerset
1307
+ @RequestId = requestid
1308
+ end
1309
+
1310
+ def deserialize(params)
1311
+ unless params['ListenerSet'].nil?
1312
+ @ListenerSet = []
1313
+ params['ListenerSet'].each do |i|
1314
+ l4listener_tmp = L4Listener.new
1315
+ l4listener_tmp.deserialize(i)
1316
+ @ListenerSet << l4listener_tmp
1317
+ end
1318
+ end
1319
+ @RequestId = params['RequestId']
1320
+ end
1321
+ end
1322
+
1323
+ # DescribeL7Backends请求参数结构体
1324
+ class DescribeL7BackendsRequest < TencentCloud::Common::AbstractModel
1325
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1326
+ # @type LoadBalancerId: String
1327
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
1328
+ # @type ListenerId: String
1329
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
1330
+ # @type DomainId: String
1331
+ # @param LocationId: 转发路径实例ID,可通过接口DescribeL7Rules查询。
1332
+ # @type LocationId: String
1333
+ # @param QueryType: 查询条件,传'all'则查询所有与规则绑定的主机信息。如果为all时,DomainId和LocationId参数没有意义不必传入,否则DomainId和LocationId参数必须传入。
1334
+ # @type QueryType: String
1335
+
1336
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainId, :LocationId, :QueryType
1337
+
1338
+ def initialize(loadbalancerid=nil, listenerid=nil, domainid=nil, locationid=nil, querytype=nil)
1339
+ @LoadBalancerId = loadbalancerid
1340
+ @ListenerId = listenerid
1341
+ @DomainId = domainid
1342
+ @LocationId = locationid
1343
+ @QueryType = querytype
1344
+ end
1345
+
1346
+ def deserialize(params)
1347
+ @LoadBalancerId = params['LoadBalancerId']
1348
+ @ListenerId = params['ListenerId']
1349
+ @DomainId = params['DomainId']
1350
+ @LocationId = params['LocationId']
1351
+ @QueryType = params['QueryType']
1352
+ end
1353
+ end
1354
+
1355
+ # DescribeL7Backends返回参数结构体
1356
+ class DescribeL7BackendsResponse < TencentCloud::Common::AbstractModel
1357
+ # @param BackendSet: 返回的绑定关系列表。
1358
+ # @type BackendSet: Array
1359
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1360
+ # @type RequestId: String
1361
+
1362
+ attr_accessor :BackendSet, :RequestId
1363
+
1364
+ def initialize(backendset=nil, requestid=nil)
1365
+ @BackendSet = backendset
1366
+ @RequestId = requestid
1367
+ end
1368
+
1369
+ def deserialize(params)
1370
+ unless params['BackendSet'].nil?
1371
+ @BackendSet = []
1372
+ params['BackendSet'].each do |i|
1373
+ l7backend_tmp = L7Backend.new
1374
+ l7backend_tmp.deserialize(i)
1375
+ @BackendSet << l7backend_tmp
1376
+ end
1377
+ end
1378
+ @RequestId = params['RequestId']
1379
+ end
1380
+ end
1381
+
1382
+ # DescribeL7ListenerInfo请求参数结构体
1383
+ class DescribeL7ListenerInfoRequest < TencentCloud::Common::AbstractModel
1384
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1385
+ # @type LoadBalancerId: String
1386
+ # @param SearchKey: 查找的键值,可用于模糊查找有该转发域名的监听器。
1387
+ # @type SearchKey: String
1388
+ # @param InstanceIds: 主机ID或虚机IP列表,可用于获取绑定了该主机的监听器。
1389
+ # @type InstanceIds: Array
1390
+ # @param IfGetBackendInfo: 是否获取转发规则下的主机信息。默认为0,不获取。
1391
+ # @type IfGetBackendInfo: Integer
1392
+
1393
+ attr_accessor :LoadBalancerId, :SearchKey, :InstanceIds, :IfGetBackendInfo
1394
+
1395
+ def initialize(loadbalancerid=nil, searchkey=nil, instanceids=nil, ifgetbackendinfo=nil)
1396
+ @LoadBalancerId = loadbalancerid
1397
+ @SearchKey = searchkey
1398
+ @InstanceIds = instanceids
1399
+ @IfGetBackendInfo = ifgetbackendinfo
1400
+ end
1401
+
1402
+ def deserialize(params)
1403
+ @LoadBalancerId = params['LoadBalancerId']
1404
+ @SearchKey = params['SearchKey']
1405
+ @InstanceIds = params['InstanceIds']
1406
+ @IfGetBackendInfo = params['IfGetBackendInfo']
1407
+ end
1408
+ end
1409
+
1410
+ # DescribeL7ListenerInfo返回参数结构体
1411
+ class DescribeL7ListenerInfoResponse < TencentCloud::Common::AbstractModel
1412
+ # @param ListenerSet: 返回的七层监听器列表。
1413
+ # @type ListenerSet: Array
1414
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1415
+ # @type RequestId: String
1416
+
1417
+ attr_accessor :ListenerSet, :RequestId
1418
+
1419
+ def initialize(listenerset=nil, requestid=nil)
1420
+ @ListenerSet = listenerset
1421
+ @RequestId = requestid
1422
+ end
1423
+
1424
+ def deserialize(params)
1425
+ unless params['ListenerSet'].nil?
1426
+ @ListenerSet = []
1427
+ params['ListenerSet'].each do |i|
1428
+ l7listenerinfo_tmp = L7ListenerInfo.new
1429
+ l7listenerinfo_tmp.deserialize(i)
1430
+ @ListenerSet << l7listenerinfo_tmp
1431
+ end
1432
+ end
1433
+ @RequestId = params['RequestId']
1434
+ end
1435
+ end
1436
+
1437
+ # DescribeL7ListenersEx请求参数结构体
1438
+ class DescribeL7ListenersExRequest < TencentCloud::Common::AbstractModel
1439
+ # @param TrafficMirrorId: 返回的监听器中标识是否绑定在此流量镜像中。
1440
+ # @type TrafficMirrorId: String
1441
+ # @param VpcId: 待获取监听器所在的VPC的ID。
1442
+ # @type VpcId: String
1443
+ # @param Offset: 此VPC中获取负载均衡的偏移。
1444
+ # @type Offset: Integer
1445
+ # @param Limit: 此VPC中获取负载均衡的数量。
1446
+ # @type Limit: Integer
1447
+ # @param Filters: 过滤条件。
1448
+ # LoadBalancerId - String - (过滤条件)负载均衡ID。
1449
+ # LoadBalancerName - String - (过滤条件)负载均衡名称。
1450
+ # Vip - String - (过滤条件)VIP。
1451
+ # ListenerId - String - (过滤条件)监听器ID。
1452
+ # ListenerName - String - (过滤条件)监听器名称。
1453
+ # Protocol - String - (过滤条件)七层协议。
1454
+ # LoadBalancerPort - String - (过滤条件)监听器端口。
1455
+ # @type Filters: Array
1456
+
1457
+ attr_accessor :TrafficMirrorId, :VpcId, :Offset, :Limit, :Filters
1458
+
1459
+ def initialize(trafficmirrorid=nil, vpcid=nil, offset=nil, limit=nil, filters=nil)
1460
+ @TrafficMirrorId = trafficmirrorid
1461
+ @VpcId = vpcid
1462
+ @Offset = offset
1463
+ @Limit = limit
1464
+ @Filters = filters
1465
+ end
1466
+
1467
+ def deserialize(params)
1468
+ @TrafficMirrorId = params['TrafficMirrorId']
1469
+ @VpcId = params['VpcId']
1470
+ @Offset = params['Offset']
1471
+ @Limit = params['Limit']
1472
+ unless params['Filters'].nil?
1473
+ @Filters = []
1474
+ params['Filters'].each do |i|
1475
+ filter_tmp = Filter.new
1476
+ filter_tmp.deserialize(i)
1477
+ @Filters << filter_tmp
1478
+ end
1479
+ end
1480
+ end
1481
+ end
1482
+
1483
+ # DescribeL7ListenersEx返回参数结构体
1484
+ class DescribeL7ListenersExResponse < TencentCloud::Common::AbstractModel
1485
+ # @param TotalCount: 此指定VPC中负载均衡的总数。
1486
+ # @type TotalCount: Integer
1487
+ # @param ListenerSet: 符合条件的监听器。
1488
+ # @type ListenerSet: Array
1489
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1490
+ # @type RequestId: String
1491
+
1492
+ attr_accessor :TotalCount, :ListenerSet, :RequestId
1493
+
1494
+ def initialize(totalcount=nil, listenerset=nil, requestid=nil)
1495
+ @TotalCount = totalcount
1496
+ @ListenerSet = listenerset
1497
+ @RequestId = requestid
1498
+ end
1499
+
1500
+ def deserialize(params)
1501
+ @TotalCount = params['TotalCount']
1502
+ unless params['ListenerSet'].nil?
1503
+ @ListenerSet = []
1504
+ params['ListenerSet'].each do |i|
1505
+ l7exlistener_tmp = L7ExListener.new
1506
+ l7exlistener_tmp.deserialize(i)
1507
+ @ListenerSet << l7exlistener_tmp
1508
+ end
1509
+ end
1510
+ @RequestId = params['RequestId']
1511
+ end
1512
+ end
1513
+
1514
+ # DescribeL7Listeners请求参数结构体
1515
+ class DescribeL7ListenersRequest < TencentCloud::Common::AbstractModel
1516
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1517
+ # @type LoadBalancerId: String
1518
+ # @param ListenerIds: 七层监听器实例ID列表,可通过接口DescribeL7Listeners查询。
1519
+ # @type ListenerIds: Array
1520
+
1521
+ attr_accessor :LoadBalancerId, :ListenerIds
1522
+
1523
+ def initialize(loadbalancerid=nil, listenerids=nil)
1524
+ @LoadBalancerId = loadbalancerid
1525
+ @ListenerIds = listenerids
1526
+ end
1527
+
1528
+ def deserialize(params)
1529
+ @LoadBalancerId = params['LoadBalancerId']
1530
+ @ListenerIds = params['ListenerIds']
1531
+ end
1532
+ end
1533
+
1534
+ # DescribeL7Listeners返回参数结构体
1535
+ class DescribeL7ListenersResponse < TencentCloud::Common::AbstractModel
1536
+ # @param ListenerSet: 返回的七层监听器列表。
1537
+ # @type ListenerSet: Array
1538
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1539
+ # @type RequestId: String
1540
+
1541
+ attr_accessor :ListenerSet, :RequestId
1542
+
1543
+ def initialize(listenerset=nil, requestid=nil)
1544
+ @ListenerSet = listenerset
1545
+ @RequestId = requestid
1546
+ end
1547
+
1548
+ def deserialize(params)
1549
+ unless params['ListenerSet'].nil?
1550
+ @ListenerSet = []
1551
+ params['ListenerSet'].each do |i|
1552
+ l7listener_tmp = L7Listener.new
1553
+ l7listener_tmp.deserialize(i)
1554
+ @ListenerSet << l7listener_tmp
1555
+ end
1556
+ end
1557
+ @RequestId = params['RequestId']
1558
+ end
1559
+ end
1560
+
1561
+ # DescribeL7Rules请求参数结构体
1562
+ class DescribeL7RulesRequest < TencentCloud::Common::AbstractModel
1563
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1564
+ # @type LoadBalancerId: String
1565
+ # @param ListenerId: 七层监听器ID,可通过接口DescribeL7Listeners查询。
1566
+ # @type ListenerId: String
1567
+ # @param DomainIds: 转发域名ID列表,可通过接口DescribeL7Rules查询。
1568
+ # @type DomainIds: Array
1569
+
1570
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainIds
1571
+
1572
+ def initialize(loadbalancerid=nil, listenerid=nil, domainids=nil)
1573
+ @LoadBalancerId = loadbalancerid
1574
+ @ListenerId = listenerid
1575
+ @DomainIds = domainids
1576
+ end
1577
+
1578
+ def deserialize(params)
1579
+ @LoadBalancerId = params['LoadBalancerId']
1580
+ @ListenerId = params['ListenerId']
1581
+ @DomainIds = params['DomainIds']
1582
+ end
1583
+ end
1584
+
1585
+ # DescribeL7Rules返回参数结构体
1586
+ class DescribeL7RulesResponse < TencentCloud::Common::AbstractModel
1587
+ # @param RuleSet: 返回的转发规则列表。
1588
+ # @type RuleSet: Array
1589
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1590
+ # @type RequestId: String
1591
+
1592
+ attr_accessor :RuleSet, :RequestId
1593
+
1594
+ def initialize(ruleset=nil, requestid=nil)
1595
+ @RuleSet = ruleset
1596
+ @RequestId = requestid
1597
+ end
1598
+
1599
+ def deserialize(params)
1600
+ unless params['RuleSet'].nil?
1601
+ @RuleSet = []
1602
+ params['RuleSet'].each do |i|
1603
+ l7rule_tmp = L7Rule.new
1604
+ l7rule_tmp.deserialize(i)
1605
+ @RuleSet << l7rule_tmp
1606
+ end
1607
+ end
1608
+ @RequestId = params['RequestId']
1609
+ end
1610
+ end
1611
+
1612
+ # DescribeLoadBalancerPortInfo请求参数结构体
1613
+ class DescribeLoadBalancerPortInfoRequest < TencentCloud::Common::AbstractModel
1614
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
1615
+ # @type LoadBalancerId: String
1616
+
1617
+ attr_accessor :LoadBalancerId
1618
+
1619
+ def initialize(loadbalancerid=nil)
1620
+ @LoadBalancerId = loadbalancerid
1621
+ end
1622
+
1623
+ def deserialize(params)
1624
+ @LoadBalancerId = params['LoadBalancerId']
1625
+ end
1626
+ end
1627
+
1628
+ # DescribeLoadBalancerPortInfo返回参数结构体
1629
+ class DescribeLoadBalancerPortInfoResponse < TencentCloud::Common::AbstractModel
1630
+ # @param ListenerSet: 返回的监听器列表(四层和七层)。
1631
+ # @type ListenerSet: Array
1632
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1633
+ # @type RequestId: String
1634
+
1635
+ attr_accessor :ListenerSet, :RequestId
1636
+
1637
+ def initialize(listenerset=nil, requestid=nil)
1638
+ @ListenerSet = listenerset
1639
+ @RequestId = requestid
1640
+ end
1641
+
1642
+ def deserialize(params)
1643
+ unless params['ListenerSet'].nil?
1644
+ @ListenerSet = []
1645
+ params['ListenerSet'].each do |i|
1646
+ loadbalancerportinfolistener_tmp = LoadBalancerPortInfoListener.new
1647
+ loadbalancerportinfolistener_tmp.deserialize(i)
1648
+ @ListenerSet << loadbalancerportinfolistener_tmp
1649
+ end
1650
+ end
1651
+ @RequestId = params['RequestId']
1652
+ end
1653
+ end
1654
+
1655
+ # DescribeLoadBalancerTaskResult请求参数结构体
1656
+ class DescribeLoadBalancerTaskResultRequest < TencentCloud::Common::AbstractModel
1657
+ # @param TaskId: 任务ID。由具体的异步操作接口提供。
1658
+ # @type TaskId: String
1659
+
1660
+ attr_accessor :TaskId
1661
+
1662
+ def initialize(taskid=nil)
1663
+ @TaskId = taskid
1664
+ end
1665
+
1666
+ def deserialize(params)
1667
+ @TaskId = params['TaskId']
1668
+ end
1669
+ end
1670
+
1671
+ # DescribeLoadBalancerTaskResult返回参数结构体
1672
+ class DescribeLoadBalancerTaskResultResponse < TencentCloud::Common::AbstractModel
1673
+ # @param Status: 任务当前状态。0:成功,1:失败,2:进行中。
1674
+ # @type Status: Integer
1675
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1676
+ # @type RequestId: String
1677
+
1678
+ attr_accessor :Status, :RequestId
1679
+
1680
+ def initialize(status=nil, requestid=nil)
1681
+ @Status = status
1682
+ @RequestId = requestid
1683
+ end
1684
+
1685
+ def deserialize(params)
1686
+ @Status = params['Status']
1687
+ @RequestId = params['RequestId']
1688
+ end
1689
+ end
1690
+
1691
+ # DescribeLoadBalancers请求参数结构体
1692
+ class DescribeLoadBalancersRequest < TencentCloud::Common::AbstractModel
1693
+ # @param LoadBalancerIds: 负载均衡器ID数组
1694
+ # @type LoadBalancerIds: Array
1695
+ # @param LoadBalancerType: 负载均衡的类型 : open表示公网LB类型,internal表示内网LB类型
1696
+ # @type LoadBalancerType: String
1697
+ # @param LoadBalancerName: 负载均衡器名称
1698
+ # @type LoadBalancerName: String
1699
+ # @param Domain: 负载均衡域名。规则:1-60个小写英文字母、数字、点号“.”或连接线“-”。内网类型的负载均衡不能配置该字段
1700
+ # @type Domain: String
1701
+ # @param LoadBalancerVips: 负载均衡获得的公网IP地址,支持多个
1702
+ # @type LoadBalancerVips: Array
1703
+ # @param Offset: 数据偏移量,默认为0
1704
+ # @type Offset: Integer
1705
+ # @param Limit: 返回数据长度,默认为20
1706
+ # @type Limit: Integer
1707
+ # @param SearchKey: 模糊查找名称、域名、VIP
1708
+ # @type SearchKey: String
1709
+ # @param OrderBy: 排序字段,支持:loadBalancerName,createTime,domain,loadBalancerType
1710
+ # @type OrderBy: String
1711
+ # @param OrderType: 1倒序,0顺序,默认顺序
1712
+ # @type OrderType: Integer
1713
+ # @param ProjectId: 项目ID
1714
+ # @type ProjectId: Integer
1715
+ # @param Exclusive: 是否筛选独占集群,0表示非独占集群,1表示四层独占集群,2表示七层独占集群,3表示四层和七层独占集群,4表示共享容灾
1716
+ # @type Exclusive: Integer
1717
+ # @param TgwSetType: 该负载均衡对应的tgw集群(fullnat,tunnel,dnat)
1718
+ # @type TgwSetType: String
1719
+ # @param VpcId: 该负载均衡对应的所在的私有网络ID
1720
+ # @type VpcId: String
1721
+ # @param QueryType: 'CONFLIST' 查询带confId的LB列表,'CONFID' 查询某个confId绑定的LB列表
1722
+ # @type QueryType: String
1723
+ # @param ConfId: 个性化配置ID
1724
+ # @type ConfId: String
1725
+
1726
+ attr_accessor :LoadBalancerIds, :LoadBalancerType, :LoadBalancerName, :Domain, :LoadBalancerVips, :Offset, :Limit, :SearchKey, :OrderBy, :OrderType, :ProjectId, :Exclusive, :TgwSetType, :VpcId, :QueryType, :ConfId
1727
+
1728
+ def initialize(loadbalancerids=nil, loadbalancertype=nil, loadbalancername=nil, domain=nil, loadbalancervips=nil, offset=nil, limit=nil, searchkey=nil, orderby=nil, ordertype=nil, projectid=nil, exclusive=nil, tgwsettype=nil, vpcid=nil, querytype=nil, confid=nil)
1729
+ @LoadBalancerIds = loadbalancerids
1730
+ @LoadBalancerType = loadbalancertype
1731
+ @LoadBalancerName = loadbalancername
1732
+ @Domain = domain
1733
+ @LoadBalancerVips = loadbalancervips
1734
+ @Offset = offset
1735
+ @Limit = limit
1736
+ @SearchKey = searchkey
1737
+ @OrderBy = orderby
1738
+ @OrderType = ordertype
1739
+ @ProjectId = projectid
1740
+ @Exclusive = exclusive
1741
+ @TgwSetType = tgwsettype
1742
+ @VpcId = vpcid
1743
+ @QueryType = querytype
1744
+ @ConfId = confid
1745
+ end
1746
+
1747
+ def deserialize(params)
1748
+ @LoadBalancerIds = params['LoadBalancerIds']
1749
+ @LoadBalancerType = params['LoadBalancerType']
1750
+ @LoadBalancerName = params['LoadBalancerName']
1751
+ @Domain = params['Domain']
1752
+ @LoadBalancerVips = params['LoadBalancerVips']
1753
+ @Offset = params['Offset']
1754
+ @Limit = params['Limit']
1755
+ @SearchKey = params['SearchKey']
1756
+ @OrderBy = params['OrderBy']
1757
+ @OrderType = params['OrderType']
1758
+ @ProjectId = params['ProjectId']
1759
+ @Exclusive = params['Exclusive']
1760
+ @TgwSetType = params['TgwSetType']
1761
+ @VpcId = params['VpcId']
1762
+ @QueryType = params['QueryType']
1763
+ @ConfId = params['ConfId']
1764
+ end
1765
+ end
1766
+
1767
+ # DescribeLoadBalancers返回参数结构体
1768
+ class DescribeLoadBalancersResponse < TencentCloud::Common::AbstractModel
1769
+ # @param LoadBalancerSet: 返回负载均衡信息列表。
1770
+ # @type LoadBalancerSet: Array
1771
+ # @param TotalCount: 符合条件的负载均衡总数。
1772
+ # @type TotalCount: Integer
1773
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1774
+ # @type RequestId: String
1775
+
1776
+ attr_accessor :LoadBalancerSet, :TotalCount, :RequestId
1777
+
1778
+ def initialize(loadbalancerset=nil, totalcount=nil, requestid=nil)
1779
+ @LoadBalancerSet = loadbalancerset
1780
+ @TotalCount = totalcount
1781
+ @RequestId = requestid
1782
+ end
1783
+
1784
+ def deserialize(params)
1785
+ unless params['LoadBalancerSet'].nil?
1786
+ @LoadBalancerSet = []
1787
+ params['LoadBalancerSet'].each do |i|
1788
+ loadbalancer_tmp = LoadBalancer.new
1789
+ loadbalancer_tmp.deserialize(i)
1790
+ @LoadBalancerSet << loadbalancer_tmp
1791
+ end
1792
+ end
1793
+ @TotalCount = params['TotalCount']
1794
+ @RequestId = params['RequestId']
1795
+ end
1796
+ end
1797
+
1798
+ # DescribeTrafficMirrorListeners请求参数结构体
1799
+ class DescribeTrafficMirrorListenersRequest < TencentCloud::Common::AbstractModel
1800
+ # @param TrafficMirrorId: 流量镜像实例ID。
1801
+ # @type TrafficMirrorId: String
1802
+ # @param Offset: 分页的偏移量,也即从第几条记录开始查询
1803
+ # @type Offset: Integer
1804
+ # @param Limit: 单次查询返回的条目数,默认值:500。
1805
+ # @type Limit: Integer
1806
+ # @param SearchLoadBalancerIds: 待搜索的负载均衡Id。
1807
+ # @type SearchLoadBalancerIds: Array
1808
+ # @param SearchLoadBalancerNames: 待搜索的负载均衡名称。
1809
+ # @type SearchLoadBalancerNames: Array
1810
+ # @param SearchVips: 待搜索的Vip。
1811
+ # @type SearchVips: Array
1812
+ # @param SearchListenerIds: 待搜索的监听器ID。
1813
+ # @type SearchListenerIds: Array
1814
+ # @param SearchListenerNames: 待搜索的监听器名称。
1815
+ # @type SearchListenerNames: Array
1816
+ # @param SearchProtocols: 待搜索的协议名称。
1817
+ # @type SearchProtocols: Array
1818
+ # @param SearchLoadBalancerPorts: 待搜索的端口。
1819
+ # @type SearchLoadBalancerPorts: Array
1820
+
1821
+ attr_accessor :TrafficMirrorId, :Offset, :Limit, :SearchLoadBalancerIds, :SearchLoadBalancerNames, :SearchVips, :SearchListenerIds, :SearchListenerNames, :SearchProtocols, :SearchLoadBalancerPorts
1822
+
1823
+ def initialize(trafficmirrorid=nil, offset=nil, limit=nil, searchloadbalancerids=nil, searchloadbalancernames=nil, searchvips=nil, searchlistenerids=nil, searchlistenernames=nil, searchprotocols=nil, searchloadbalancerports=nil)
1824
+ @TrafficMirrorId = trafficmirrorid
1825
+ @Offset = offset
1826
+ @Limit = limit
1827
+ @SearchLoadBalancerIds = searchloadbalancerids
1828
+ @SearchLoadBalancerNames = searchloadbalancernames
1829
+ @SearchVips = searchvips
1830
+ @SearchListenerIds = searchlistenerids
1831
+ @SearchListenerNames = searchlistenernames
1832
+ @SearchProtocols = searchprotocols
1833
+ @SearchLoadBalancerPorts = searchloadbalancerports
1834
+ end
1835
+
1836
+ def deserialize(params)
1837
+ @TrafficMirrorId = params['TrafficMirrorId']
1838
+ @Offset = params['Offset']
1839
+ @Limit = params['Limit']
1840
+ @SearchLoadBalancerIds = params['SearchLoadBalancerIds']
1841
+ @SearchLoadBalancerNames = params['SearchLoadBalancerNames']
1842
+ @SearchVips = params['SearchVips']
1843
+ @SearchListenerIds = params['SearchListenerIds']
1844
+ @SearchListenerNames = params['SearchListenerNames']
1845
+ @SearchProtocols = params['SearchProtocols']
1846
+ @SearchLoadBalancerPorts = params['SearchLoadBalancerPorts']
1847
+ end
1848
+ end
1849
+
1850
+ # DescribeTrafficMirrorListeners返回参数结构体
1851
+ class DescribeTrafficMirrorListenersResponse < TencentCloud::Common::AbstractModel
1852
+ # @param ListenerSet: 监听器列表。
1853
+ # @type ListenerSet: Array
1854
+ # @param TotalCount: 监听器总数。
1855
+ # @type TotalCount: Integer
1856
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1857
+ # @type RequestId: String
1858
+
1859
+ attr_accessor :ListenerSet, :TotalCount, :RequestId
1860
+
1861
+ def initialize(listenerset=nil, totalcount=nil, requestid=nil)
1862
+ @ListenerSet = listenerset
1863
+ @TotalCount = totalcount
1864
+ @RequestId = requestid
1865
+ end
1866
+
1867
+ def deserialize(params)
1868
+ unless params['ListenerSet'].nil?
1869
+ @ListenerSet = []
1870
+ params['ListenerSet'].each do |i|
1871
+ trafficmirrorlistener_tmp = TrafficMirrorListener.new
1872
+ trafficmirrorlistener_tmp.deserialize(i)
1873
+ @ListenerSet << trafficmirrorlistener_tmp
1874
+ end
1875
+ end
1876
+ @TotalCount = params['TotalCount']
1877
+ @RequestId = params['RequestId']
1878
+ end
1879
+ end
1880
+
1881
+ # 流量镜像进行健康检查的接收机信息。
1882
+ class DescribeTrafficMirrorReceiver < TencentCloud::Common::AbstractModel
1883
+ # @param InstanceId: 物理机实例ID。
1884
+ # @type InstanceId: String
1885
+ # @param Port: 物理机绑定的端口。
1886
+ # @type Port: Integer
1887
+
1888
+ attr_accessor :InstanceId, :Port
1889
+
1890
+ def initialize(instanceid=nil, port=nil)
1891
+ @InstanceId = instanceid
1892
+ @Port = port
1893
+ end
1894
+
1895
+ def deserialize(params)
1896
+ @InstanceId = params['InstanceId']
1897
+ @Port = params['Port']
1898
+ end
1899
+ end
1900
+
1901
+ # DescribeTrafficMirrorReceiverHealthStatus请求参数结构体
1902
+ class DescribeTrafficMirrorReceiverHealthStatusRequest < TencentCloud::Common::AbstractModel
1903
+ # @param TrafficMirrorId: 查询所在的流量镜像ID。
1904
+ # @type TrafficMirrorId: String
1905
+ # @param ReceiverSet: 流量镜像接收机实例ID和端口数组。
1906
+ # @type ReceiverSet: Array
1907
+
1908
+ attr_accessor :TrafficMirrorId, :ReceiverSet
1909
+
1910
+ def initialize(trafficmirrorid=nil, receiverset=nil)
1911
+ @TrafficMirrorId = trafficmirrorid
1912
+ @ReceiverSet = receiverset
1913
+ end
1914
+
1915
+ def deserialize(params)
1916
+ @TrafficMirrorId = params['TrafficMirrorId']
1917
+ unless params['ReceiverSet'].nil?
1918
+ @ReceiverSet = []
1919
+ params['ReceiverSet'].each do |i|
1920
+ describetrafficmirrorreceiver_tmp = DescribeTrafficMirrorReceiver.new
1921
+ describetrafficmirrorreceiver_tmp.deserialize(i)
1922
+ @ReceiverSet << describetrafficmirrorreceiver_tmp
1923
+ end
1924
+ end
1925
+ end
1926
+ end
1927
+
1928
+ # DescribeTrafficMirrorReceiverHealthStatus返回参数结构体
1929
+ class DescribeTrafficMirrorReceiverHealthStatusResponse < TencentCloud::Common::AbstractModel
1930
+ # @param ReceiversStatusSet: 内网IP和端口对应的状态。
1931
+ # @type ReceiversStatusSet: Array
1932
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
1933
+ # @type RequestId: String
1934
+
1935
+ attr_accessor :ReceiversStatusSet, :RequestId
1936
+
1937
+ def initialize(receiversstatusset=nil, requestid=nil)
1938
+ @ReceiversStatusSet = receiversstatusset
1939
+ @RequestId = requestid
1940
+ end
1941
+
1942
+ def deserialize(params)
1943
+ unless params['ReceiversStatusSet'].nil?
1944
+ @ReceiversStatusSet = []
1945
+ params['ReceiversStatusSet'].each do |i|
1946
+ trafficmirrorreciversstatus_tmp = TrafficMirrorReciversStatus.new
1947
+ trafficmirrorreciversstatus_tmp.deserialize(i)
1948
+ @ReceiversStatusSet << trafficmirrorreciversstatus_tmp
1949
+ end
1950
+ end
1951
+ @RequestId = params['RequestId']
1952
+ end
1953
+ end
1954
+
1955
+ # DescribeTrafficMirrorReceivers请求参数结构体
1956
+ class DescribeTrafficMirrorReceiversRequest < TencentCloud::Common::AbstractModel
1957
+ # @param TrafficMirrorId: 流量镜像实例ID。
1958
+ # @type TrafficMirrorId: String
1959
+ # @param InstanceIds: 接收机黑石物理机实例ID数组。
1960
+ # @type InstanceIds: Array
1961
+ # @param Ports: 接收机接收端口数组。
1962
+ # @type Ports: Array
1963
+ # @param Weights: 接收机实例权重数组。
1964
+ # @type Weights: Array
1965
+ # @param Offset: 分页的偏移量,也即从第几条记录开始查询
1966
+ # @type Offset: Integer
1967
+ # @param Limit: 单次查询返回的条目数,默认值:500。
1968
+ # @type Limit: Integer
1969
+ # @param VagueStr: 搜索instance或者alias
1970
+ # @type VagueStr: String
1971
+ # @param VagueIp: 搜索IP
1972
+ # @type VagueIp: String
1973
+
1974
+ attr_accessor :TrafficMirrorId, :InstanceIds, :Ports, :Weights, :Offset, :Limit, :VagueStr, :VagueIp
1975
+
1976
+ def initialize(trafficmirrorid=nil, instanceids=nil, ports=nil, weights=nil, offset=nil, limit=nil, vaguestr=nil, vagueip=nil)
1977
+ @TrafficMirrorId = trafficmirrorid
1978
+ @InstanceIds = instanceids
1979
+ @Ports = ports
1980
+ @Weights = weights
1981
+ @Offset = offset
1982
+ @Limit = limit
1983
+ @VagueStr = vaguestr
1984
+ @VagueIp = vagueip
1985
+ end
1986
+
1987
+ def deserialize(params)
1988
+ @TrafficMirrorId = params['TrafficMirrorId']
1989
+ @InstanceIds = params['InstanceIds']
1990
+ @Ports = params['Ports']
1991
+ @Weights = params['Weights']
1992
+ @Offset = params['Offset']
1993
+ @Limit = params['Limit']
1994
+ @VagueStr = params['VagueStr']
1995
+ @VagueIp = params['VagueIp']
1996
+ end
1997
+ end
1998
+
1999
+ # DescribeTrafficMirrorReceivers返回参数结构体
2000
+ class DescribeTrafficMirrorReceiversResponse < TencentCloud::Common::AbstractModel
2001
+ # @param ReceiverSet: 接收机列表,具体结构描述如data结构所示。
2002
+ # @type ReceiverSet: Array
2003
+ # @param TotalCount: 接收机总数。
2004
+ # @type TotalCount: Integer
2005
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2006
+ # @type RequestId: String
2007
+
2008
+ attr_accessor :ReceiverSet, :TotalCount, :RequestId
2009
+
2010
+ def initialize(receiverset=nil, totalcount=nil, requestid=nil)
2011
+ @ReceiverSet = receiverset
2012
+ @TotalCount = totalcount
2013
+ @RequestId = requestid
2014
+ end
2015
+
2016
+ def deserialize(params)
2017
+ unless params['ReceiverSet'].nil?
2018
+ @ReceiverSet = []
2019
+ params['ReceiverSet'].each do |i|
2020
+ trafficmirrorreceiver_tmp = TrafficMirrorReceiver.new
2021
+ trafficmirrorreceiver_tmp.deserialize(i)
2022
+ @ReceiverSet << trafficmirrorreceiver_tmp
2023
+ end
2024
+ end
2025
+ @TotalCount = params['TotalCount']
2026
+ @RequestId = params['RequestId']
2027
+ end
2028
+ end
2029
+
2030
+ # DescribeTrafficMirrors请求参数结构体
2031
+ class DescribeTrafficMirrorsRequest < TencentCloud::Common::AbstractModel
2032
+ # @param TrafficMirrorIds: 流量镜像实例ID的数组,支持批量查询
2033
+ # @type TrafficMirrorIds: Array
2034
+ # @param Aliases: 流量镜像实例别名数组。
2035
+ # @type Aliases: Array
2036
+ # @param VpcIds: 流量镜像实例所属的私有网络ID数组,形如:vpc-xxx。
2037
+ # @type VpcIds: Array
2038
+ # @param Offset: 分页的偏移量,也即从第几条记录开始查询
2039
+ # @type Offset: Integer
2040
+ # @param Limit: 单次查询返回的条目数,默认值:500。
2041
+ # @type Limit: Integer
2042
+ # @param OrderField: 排序字段。trafficMirrorId或者createTime。
2043
+ # @type OrderField: String
2044
+ # @param Order: 排序方式,取值:0:增序(默认),1:降序
2045
+ # @type Order: Integer
2046
+ # @param SearchKey: 模糊匹配trafficMirrorId或者alias字段。
2047
+ # @type SearchKey: String
2048
+
2049
+ attr_accessor :TrafficMirrorIds, :Aliases, :VpcIds, :Offset, :Limit, :OrderField, :Order, :SearchKey
2050
+
2051
+ def initialize(trafficmirrorids=nil, aliases=nil, vpcids=nil, offset=nil, limit=nil, orderfield=nil, order=nil, searchkey=nil)
2052
+ @TrafficMirrorIds = trafficmirrorids
2053
+ @Aliases = aliases
2054
+ @VpcIds = vpcids
2055
+ @Offset = offset
2056
+ @Limit = limit
2057
+ @OrderField = orderfield
2058
+ @Order = order
2059
+ @SearchKey = searchkey
2060
+ end
2061
+
2062
+ def deserialize(params)
2063
+ @TrafficMirrorIds = params['TrafficMirrorIds']
2064
+ @Aliases = params['Aliases']
2065
+ @VpcIds = params['VpcIds']
2066
+ @Offset = params['Offset']
2067
+ @Limit = params['Limit']
2068
+ @OrderField = params['OrderField']
2069
+ @Order = params['Order']
2070
+ @SearchKey = params['SearchKey']
2071
+ end
2072
+ end
2073
+
2074
+ # DescribeTrafficMirrors返回参数结构体
2075
+ class DescribeTrafficMirrorsResponse < TencentCloud::Common::AbstractModel
2076
+ # @param TotalCount: 流量镜像总数。
2077
+ # @type TotalCount: Integer
2078
+ # @param TrafficMirrorSet: 对象数组。数组元素为流量镜像信息,具体结构描述如list结构所示。
2079
+ # @type TrafficMirrorSet: Array
2080
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
2081
+ # @type RequestId: String
2082
+
2083
+ attr_accessor :TotalCount, :TrafficMirrorSet, :RequestId
2084
+
2085
+ def initialize(totalcount=nil, trafficmirrorset=nil, requestid=nil)
2086
+ @TotalCount = totalcount
2087
+ @TrafficMirrorSet = trafficmirrorset
2088
+ @RequestId = requestid
2089
+ end
2090
+
2091
+ def deserialize(params)
2092
+ @TotalCount = params['TotalCount']
2093
+ unless params['TrafficMirrorSet'].nil?
2094
+ @TrafficMirrorSet = []
2095
+ params['TrafficMirrorSet'].each do |i|
2096
+ trafficmirror_tmp = TrafficMirror.new
2097
+ trafficmirror_tmp.deserialize(i)
2098
+ @TrafficMirrorSet << trafficmirror_tmp
2099
+ end
2100
+ end
2101
+ @RequestId = params['RequestId']
2102
+ end
2103
+ end
2104
+
2105
+ # 获取设备绑定信息时返回的所绑定的主机信息。
2106
+ class DevicesBindInfoBackend < TencentCloud::Common::AbstractModel
2107
+ # @param InstanceId: 黑石物理机的主机ID、托管主机ID或虚拟机IP。
2108
+ # @type InstanceId: String
2109
+ # @param Port: 主机端口。
2110
+ # @type Port: Integer
2111
+
2112
+ attr_accessor :InstanceId, :Port
2113
+
2114
+ def initialize(instanceid=nil, port=nil)
2115
+ @InstanceId = instanceid
2116
+ @Port = port
2117
+ end
2118
+
2119
+ def deserialize(params)
2120
+ @InstanceId = params['InstanceId']
2121
+ @Port = params['Port']
2122
+ end
2123
+ end
2124
+
2125
+ # 获取设备绑定信息时返回的四层监听器信息。
2126
+ class DevicesBindInfoL4Listener < TencentCloud::Common::AbstractModel
2127
+ # @param ListenerId: 七层监听器实例ID。
2128
+ # @type ListenerId: String
2129
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
2130
+ # @type Protocol: String
2131
+ # @param LoadBalancerPort: 七层监听器的监听端口。
2132
+ # @type LoadBalancerPort: Integer
2133
+ # @param BackendSet: 该转发路径所绑定的主机列表。
2134
+ # @type BackendSet: Array
2135
+
2136
+ attr_accessor :ListenerId, :Protocol, :LoadBalancerPort, :BackendSet
2137
+
2138
+ def initialize(listenerid=nil, protocol=nil, loadbalancerport=nil, backendset=nil)
2139
+ @ListenerId = listenerid
2140
+ @Protocol = protocol
2141
+ @LoadBalancerPort = loadbalancerport
2142
+ @BackendSet = backendset
2143
+ end
2144
+
2145
+ def deserialize(params)
2146
+ @ListenerId = params['ListenerId']
2147
+ @Protocol = params['Protocol']
2148
+ @LoadBalancerPort = params['LoadBalancerPort']
2149
+ unless params['BackendSet'].nil?
2150
+ @BackendSet = []
2151
+ params['BackendSet'].each do |i|
2152
+ devicesbindinfobackend_tmp = DevicesBindInfoBackend.new
2153
+ devicesbindinfobackend_tmp.deserialize(i)
2154
+ @BackendSet << devicesbindinfobackend_tmp
2155
+ end
2156
+ end
2157
+ end
2158
+ end
2159
+
2160
+ # 获取设备绑定信息时返回的七层监听器信息。
2161
+ class DevicesBindInfoL7Listener < TencentCloud::Common::AbstractModel
2162
+ # @param ListenerId: 七层监听器实例ID。
2163
+ # @type ListenerId: String
2164
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
2165
+ # @type Protocol: String
2166
+ # @param LoadBalancerPort: 七层监听器的监听端口。
2167
+ # @type LoadBalancerPort: Integer
2168
+ # @param RuleSet: 返回的转发规则列表。
2169
+ # @type RuleSet: Array
2170
+
2171
+ attr_accessor :ListenerId, :Protocol, :LoadBalancerPort, :RuleSet
2172
+
2173
+ def initialize(listenerid=nil, protocol=nil, loadbalancerport=nil, ruleset=nil)
2174
+ @ListenerId = listenerid
2175
+ @Protocol = protocol
2176
+ @LoadBalancerPort = loadbalancerport
2177
+ @RuleSet = ruleset
2178
+ end
2179
+
2180
+ def deserialize(params)
2181
+ @ListenerId = params['ListenerId']
2182
+ @Protocol = params['Protocol']
2183
+ @LoadBalancerPort = params['LoadBalancerPort']
2184
+ unless params['RuleSet'].nil?
2185
+ @RuleSet = []
2186
+ params['RuleSet'].each do |i|
2187
+ devicesbindinforule_tmp = DevicesBindInfoRule.new
2188
+ devicesbindinforule_tmp.deserialize(i)
2189
+ @RuleSet << devicesbindinforule_tmp
2190
+ end
2191
+ end
2192
+ end
2193
+ end
2194
+
2195
+ # 获取设备绑定信息时返回的设备被绑定所在的负载均衡信息。
2196
+ class DevicesBindInfoLoadBalancer < TencentCloud::Common::AbstractModel
2197
+ # @param LoadBalancerId: 负载均衡实例ID。
2198
+ # @type LoadBalancerId: String
2199
+ # @param AppId: 开发商AppId。
2200
+ # @type AppId: Integer
2201
+ # @param ProjectId: 负载均衡所属的项目ID。
2202
+ # @type ProjectId: Integer
2203
+ # @param VpcId: 黑石私有网络唯一ID。
2204
+ # @type VpcId: String
2205
+ # @param Vip: 负载均衡的IP地址。
2206
+ # @type Vip: String
2207
+ # @param TgwSetType: 负载均衡对应的TGW集群类别,取值为tunnel或fullnat。tunnel表示隧道集群,fullnat表示FULLNAT集群。
2208
+ # @type TgwSetType: String
2209
+ # @param Exclusive: 是否独占TGW集群。
2210
+ # @type Exclusive: Integer
2211
+ # @param L4ListenerSet: 具有该绑定关系的四层监听器列表。
2212
+ # @type L4ListenerSet: Array
2213
+ # @param L7ListenerSet: 具有该绑定关系的七层监听器列表。
2214
+ # @type L7ListenerSet: Array
2215
+
2216
+ attr_accessor :LoadBalancerId, :AppId, :ProjectId, :VpcId, :Vip, :TgwSetType, :Exclusive, :L4ListenerSet, :L7ListenerSet
2217
+
2218
+ def initialize(loadbalancerid=nil, appid=nil, projectid=nil, vpcid=nil, vip=nil, tgwsettype=nil, exclusive=nil, l4listenerset=nil, l7listenerset=nil)
2219
+ @LoadBalancerId = loadbalancerid
2220
+ @AppId = appid
2221
+ @ProjectId = projectid
2222
+ @VpcId = vpcid
2223
+ @Vip = vip
2224
+ @TgwSetType = tgwsettype
2225
+ @Exclusive = exclusive
2226
+ @L4ListenerSet = l4listenerset
2227
+ @L7ListenerSet = l7listenerset
2228
+ end
2229
+
2230
+ def deserialize(params)
2231
+ @LoadBalancerId = params['LoadBalancerId']
2232
+ @AppId = params['AppId']
2233
+ @ProjectId = params['ProjectId']
2234
+ @VpcId = params['VpcId']
2235
+ @Vip = params['Vip']
2236
+ @TgwSetType = params['TgwSetType']
2237
+ @Exclusive = params['Exclusive']
2238
+ unless params['L4ListenerSet'].nil?
2239
+ @L4ListenerSet = []
2240
+ params['L4ListenerSet'].each do |i|
2241
+ devicesbindinfol4listener_tmp = DevicesBindInfoL4Listener.new
2242
+ devicesbindinfol4listener_tmp.deserialize(i)
2243
+ @L4ListenerSet << devicesbindinfol4listener_tmp
2244
+ end
2245
+ end
2246
+ unless params['L7ListenerSet'].nil?
2247
+ @L7ListenerSet = []
2248
+ params['L7ListenerSet'].each do |i|
2249
+ devicesbindinfol7listener_tmp = DevicesBindInfoL7Listener.new
2250
+ devicesbindinfol7listener_tmp.deserialize(i)
2251
+ @L7ListenerSet << devicesbindinfol7listener_tmp
2252
+ end
2253
+ end
2254
+ end
2255
+ end
2256
+
2257
+ # 获取设备绑定信息时返回的设备所绑定的转发路径信息。
2258
+ class DevicesBindInfoLocation < TencentCloud::Common::AbstractModel
2259
+ # @param Url: 转发路径。
2260
+ # @type Url: String
2261
+ # @param LocationId: 转发路径实例ID。
2262
+ # @type LocationId: String
2263
+ # @param BackendSet: 该转发路径所绑定的主机列表。
2264
+ # @type BackendSet: Array
2265
+
2266
+ attr_accessor :Url, :LocationId, :BackendSet
2267
+
2268
+ def initialize(url=nil, locationid=nil, backendset=nil)
2269
+ @Url = url
2270
+ @LocationId = locationid
2271
+ @BackendSet = backendset
2272
+ end
2273
+
2274
+ def deserialize(params)
2275
+ @Url = params['Url']
2276
+ @LocationId = params['LocationId']
2277
+ unless params['BackendSet'].nil?
2278
+ @BackendSet = []
2279
+ params['BackendSet'].each do |i|
2280
+ devicesbindinfobackend_tmp = DevicesBindInfoBackend.new
2281
+ devicesbindinfobackend_tmp.deserialize(i)
2282
+ @BackendSet << devicesbindinfobackend_tmp
2283
+ end
2284
+ end
2285
+ end
2286
+ end
2287
+
2288
+ # 获取设备绑定信息时返回的设备所绑定的转发规则信息。
2289
+ class DevicesBindInfoRule < TencentCloud::Common::AbstractModel
2290
+ # @param Domain: 转发域名。
2291
+ # @type Domain: String
2292
+ # @param DomainId: 转发域名ID。
2293
+ # @type DomainId: String
2294
+ # @param LocationSet: 转发路径列表。
2295
+ # @type LocationSet: Array
2296
+
2297
+ attr_accessor :Domain, :DomainId, :LocationSet
2298
+
2299
+ def initialize(domain=nil, domainid=nil, locationset=nil)
2300
+ @Domain = domain
2301
+ @DomainId = domainid
2302
+ @LocationSet = locationset
2303
+ end
2304
+
2305
+ def deserialize(params)
2306
+ @Domain = params['Domain']
2307
+ @DomainId = params['DomainId']
2308
+ unless params['LocationSet'].nil?
2309
+ @LocationSet = []
2310
+ params['LocationSet'].each do |i|
2311
+ devicesbindinfolocation_tmp = DevicesBindInfoLocation.new
2312
+ devicesbindinfolocation_tmp.deserialize(i)
2313
+ @LocationSet << devicesbindinfolocation_tmp
2314
+ end
2315
+ end
2316
+ end
2317
+ end
2318
+
2319
+ # 过滤器
2320
+ class Filter < TencentCloud::Common::AbstractModel
2321
+ # @param Name: 属性名称, 若存在多个Filter时,Filter间的关系为逻辑与(AND)关系。
2322
+ # @type Name: String
2323
+ # @param Values: 属性值, 若同一个Filter存在多个Values,同一Filter下Values间的关系为逻辑或(OR)关系。
2324
+ # @type Values: Array
2325
+
2326
+ attr_accessor :Name, :Values
2327
+
2328
+ def initialize(name=nil, values=nil)
2329
+ @Name = name
2330
+ @Values = values
2331
+ end
2332
+
2333
+ def deserialize(params)
2334
+ @Name = params['Name']
2335
+ @Values = params['Values']
2336
+ end
2337
+ end
2338
+
2339
+ # 查询四层监听器返回的与监听器绑定关系的主机信息。
2340
+ class L4Backend < TencentCloud::Common::AbstractModel
2341
+ # @param BindType: 绑定类别(0代表黑石物理机,1代表虚拟机IP)。
2342
+ # @type BindType: Integer
2343
+ # @param Port: 主机端口。
2344
+ # @type Port: Integer
2345
+ # @param Weight: 权重。
2346
+ # @type Weight: Integer
2347
+ # @param Status: 当前绑定关系的健康检查状态(Dead代表不健康,Alive代表健康)。
2348
+ # @type Status: String
2349
+ # @param InstanceId: 黑石物理机的主机ID。
2350
+ # @type InstanceId: String
2351
+ # @param Alias: 黑石物理机的别名。
2352
+ # @type Alias: String
2353
+ # @param LanIp: 主机IP。
2354
+ # @type LanIp: String
2355
+ # @param Operates: 黑石物理机当前可以执行的操作。
2356
+ # @type Operates: Array
2357
+ # @param ProbePort: 主机探测端口。
2358
+ # @type ProbePort: Integer
2359
+
2360
+ attr_accessor :BindType, :Port, :Weight, :Status, :InstanceId, :Alias, :LanIp, :Operates, :ProbePort
2361
+
2362
+ def initialize(bindtype=nil, port=nil, weight=nil, status=nil, instanceid=nil, _alias=nil, lanip=nil, operates=nil, probeport=nil)
2363
+ @BindType = bindtype
2364
+ @Port = port
2365
+ @Weight = weight
2366
+ @Status = status
2367
+ @InstanceId = instanceid
2368
+ @Alias = _alias
2369
+ @LanIp = lanip
2370
+ @Operates = operates
2371
+ @ProbePort = probeport
2372
+ end
2373
+
2374
+ def deserialize(params)
2375
+ @BindType = params['BindType']
2376
+ @Port = params['Port']
2377
+ @Weight = params['Weight']
2378
+ @Status = params['Status']
2379
+ @InstanceId = params['InstanceId']
2380
+ @Alias = params['Alias']
2381
+ @LanIp = params['LanIp']
2382
+ @Operates = params['Operates']
2383
+ @ProbePort = params['ProbePort']
2384
+ end
2385
+ end
2386
+
2387
+ # 查询四层监听器时返回的四层监听器信息。
2388
+ class L4Listener < TencentCloud::Common::AbstractModel
2389
+ # @param ListenerId: 监听器ID。
2390
+ # @type ListenerId: String
2391
+ # @param ListenerName: 用户自定义的监听器名称。
2392
+ # @type ListenerName: String
2393
+ # @param Protocol: 负载均衡实例监听器协议类型,可选值tcp,udp。
2394
+ # @type Protocol: String
2395
+ # @param LoadBalancerPort: 负载均衡监听器的监听接口,可选值1~65535。
2396
+ # @type LoadBalancerPort: Integer
2397
+ # @param Bandwidth: 用于计费模式为固定带宽计费,指定监听器最大带宽值,可选值:0-1000,单位:Mbps。
2398
+ # @type Bandwidth: Integer
2399
+ # @param ListenerType: 监听器的类别:L4Listener(四层监听器),L7Listener(七层监听器)。
2400
+ # @type ListenerType: String
2401
+ # @param SessionExpire: 会话保持时间。单位:秒
2402
+ # @type SessionExpire: Integer
2403
+ # @param HealthSwitch: 是否开启了检查:1(开启)、0(关闭)。
2404
+ # @type HealthSwitch: Integer
2405
+ # @param TimeOut: 响应超时时间,单位:秒。
2406
+ # @type TimeOut: Integer
2407
+ # @param IntervalTime: 检查间隔,单位:秒。
2408
+ # @type IntervalTime: Integer
2409
+ # @param HealthNum: 负载均衡监听器健康阈值,默认值:3,表示当连续探测三次健康则表示该转发正常,可选值:2-10,单位:次。
2410
+ # @type HealthNum: Integer
2411
+ # @param UnhealthNum: 负载均衡监听器不健康阈值,默认值:3,表示当连续探测三次不健康则表示该转发不正常,可选值:2-10,单位:次。
2412
+ # @type UnhealthNum: Integer
2413
+ # @param CustomHealthSwitch: 是否开启自定义健康检查:1(开启)、0(关闭)。默认值0,表示关闭。(该字段在健康检查开启的情况下才生效)
2414
+ # @type CustomHealthSwitch: Integer
2415
+ # @param InputType: 自定义健康探测内容类型,可选值:text(文本)、hexadecimal(十六进制)。
2416
+ # @type InputType: String
2417
+ # @param LineSeparatorType: 探测内容类型为文本方式时,针对请求文本中换行替换方式。可选值:1(替换为LF)、2(替换为CR)、3(替换为LF+CR)。
2418
+ # @type LineSeparatorType: Integer
2419
+ # @param HealthRequest: 自定义探测请求内容。
2420
+ # @type HealthRequest: String
2421
+ # @param HealthResponse: 自定义探测返回内容。
2422
+ # @type HealthResponse: String
2423
+ # @param ToaFlag: 是否开启toa:1(开启)、0(关闭)。
2424
+ # @type ToaFlag: Integer
2425
+ # @param Status: 监听器当前状态(0代表创建中,1代表正常运行,2代表创建失败,3代表删除中,4代表删除失败)。
2426
+ # @type Status: Integer
2427
+ # @param AddTimestamp: 创建时间戳。
2428
+ # @type AddTimestamp: String
2429
+ # @param BalanceMode: 转发后端服务器调度类型。
2430
+ # @type BalanceMode: String
2431
+
2432
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :ListenerType, :SessionExpire, :HealthSwitch, :TimeOut, :IntervalTime, :HealthNum, :UnhealthNum, :CustomHealthSwitch, :InputType, :LineSeparatorType, :HealthRequest, :HealthResponse, :ToaFlag, :Status, :AddTimestamp, :BalanceMode
2433
+
2434
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, listenertype=nil, sessionexpire=nil, healthswitch=nil, timeout=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, customhealthswitch=nil, inputtype=nil, lineseparatortype=nil, healthrequest=nil, healthresponse=nil, toaflag=nil, status=nil, addtimestamp=nil, balancemode=nil)
2435
+ @ListenerId = listenerid
2436
+ @ListenerName = listenername
2437
+ @Protocol = protocol
2438
+ @LoadBalancerPort = loadbalancerport
2439
+ @Bandwidth = bandwidth
2440
+ @ListenerType = listenertype
2441
+ @SessionExpire = sessionexpire
2442
+ @HealthSwitch = healthswitch
2443
+ @TimeOut = timeout
2444
+ @IntervalTime = intervaltime
2445
+ @HealthNum = healthnum
2446
+ @UnhealthNum = unhealthnum
2447
+ @CustomHealthSwitch = customhealthswitch
2448
+ @InputType = inputtype
2449
+ @LineSeparatorType = lineseparatortype
2450
+ @HealthRequest = healthrequest
2451
+ @HealthResponse = healthresponse
2452
+ @ToaFlag = toaflag
2453
+ @Status = status
2454
+ @AddTimestamp = addtimestamp
2455
+ @BalanceMode = balancemode
2456
+ end
2457
+
2458
+ def deserialize(params)
2459
+ @ListenerId = params['ListenerId']
2460
+ @ListenerName = params['ListenerName']
2461
+ @Protocol = params['Protocol']
2462
+ @LoadBalancerPort = params['LoadBalancerPort']
2463
+ @Bandwidth = params['Bandwidth']
2464
+ @ListenerType = params['ListenerType']
2465
+ @SessionExpire = params['SessionExpire']
2466
+ @HealthSwitch = params['HealthSwitch']
2467
+ @TimeOut = params['TimeOut']
2468
+ @IntervalTime = params['IntervalTime']
2469
+ @HealthNum = params['HealthNum']
2470
+ @UnhealthNum = params['UnhealthNum']
2471
+ @CustomHealthSwitch = params['CustomHealthSwitch']
2472
+ @InputType = params['InputType']
2473
+ @LineSeparatorType = params['LineSeparatorType']
2474
+ @HealthRequest = params['HealthRequest']
2475
+ @HealthResponse = params['HealthResponse']
2476
+ @ToaFlag = params['ToaFlag']
2477
+ @Status = params['Status']
2478
+ @AddTimestamp = params['AddTimestamp']
2479
+ @BalanceMode = params['BalanceMode']
2480
+ end
2481
+ end
2482
+
2483
+ # 查询绑定了某主机的四层监听器时返回的四层监听器信息。
2484
+ class L4ListenerInfo < TencentCloud::Common::AbstractModel
2485
+ # @param ListenerId: 监听器ID。
2486
+ # @type ListenerId: String
2487
+ # @param ListenerName: 用户自定义的监听器名称。
2488
+ # @type ListenerName: String
2489
+ # @param Protocol: 负载均衡实例监听器协议类型,可选值tcp,udp。
2490
+ # @type Protocol: String
2491
+ # @param LoadBalancerPort: 负载均衡监听器的监听接口,可选值1~65535。
2492
+ # @type LoadBalancerPort: Integer
2493
+ # @param Bandwidth: 用于计费模式为固定带宽计费,指定监听器最大带宽值,可选值:0-1000,单位:Mbps。
2494
+ # @type Bandwidth: Integer
2495
+ # @param ListenerType: 监听器的类别:L4Listener(四层监听器),L7Listener(七层监听器)。
2496
+ # @type ListenerType: String
2497
+ # @param SessionExpire: 会话保持时间。单位:秒
2498
+ # @type SessionExpire: Integer
2499
+ # @param HealthSwitch: 是否开启了检查:1(开启)、0(关闭)。
2500
+ # @type HealthSwitch: Integer
2501
+ # @param TimeOut: 响应超时时间,单位:秒。
2502
+ # @type TimeOut: Integer
2503
+ # @param IntervalTime: 检查间隔,单位:秒。
2504
+ # @type IntervalTime: Integer
2505
+ # @param HealthNum: 负载均衡监听器健康阈值,默认值:3,表示当连续探测三次健康则表示该转发正常,可选值:2-10,单位:次。
2506
+ # @type HealthNum: Integer
2507
+ # @param UnhealthNum: 负载均衡监听器不健康阈值,默认值:3,表示当连续探测三次不健康则表示该转发不正常,可选值:2-10,单位:次。
2508
+ # @type UnhealthNum: Integer
2509
+ # @param Status: 监听器当前状态(0代表创建中,1代表正常运行,2代表创建失败,3代表删除中,4代表删除失败)。
2510
+ # @type Status: Integer
2511
+ # @param AddTimestamp: 创建时间戳。
2512
+ # @type AddTimestamp: String
2513
+ # @param CustomHealthSwitch: 是否开启自定义健康检查:1(开启)、0(关闭)。默认值0,表示关闭。(该字段在健康检查开启的情况下才生效)
2514
+ # @type CustomHealthSwitch: Integer
2515
+ # @param InputType: 自定义健康探测内容类型,可选值:text(文本)、hexadecimal(十六进制)。
2516
+ # @type InputType: String
2517
+ # @param LineSeparatorType: 探测内容类型为文本方式时,针对请求文本中换行替换方式。可选值:1(替换为LF)、2(替换为CR)、3(替换为LF+CR)。
2518
+ # @type LineSeparatorType: Integer
2519
+ # @param HealthRequest: 自定义探测请求内容。
2520
+ # @type HealthRequest: String
2521
+ # @param HealthResponse: 自定义探测返回内容。
2522
+ # @type HealthResponse: String
2523
+ # @param ToaFlag: 是否开启toa:1(开启)、0(关闭)。
2524
+ # @type ToaFlag: Integer
2525
+ # @param BalanceMode: 转发后端服务器调度类型。
2526
+ # @type BalanceMode: String
2527
+
2528
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :ListenerType, :SessionExpire, :HealthSwitch, :TimeOut, :IntervalTime, :HealthNum, :UnhealthNum, :Status, :AddTimestamp, :CustomHealthSwitch, :InputType, :LineSeparatorType, :HealthRequest, :HealthResponse, :ToaFlag, :BalanceMode
2529
+
2530
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, listenertype=nil, sessionexpire=nil, healthswitch=nil, timeout=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, status=nil, addtimestamp=nil, customhealthswitch=nil, inputtype=nil, lineseparatortype=nil, healthrequest=nil, healthresponse=nil, toaflag=nil, balancemode=nil)
2531
+ @ListenerId = listenerid
2532
+ @ListenerName = listenername
2533
+ @Protocol = protocol
2534
+ @LoadBalancerPort = loadbalancerport
2535
+ @Bandwidth = bandwidth
2536
+ @ListenerType = listenertype
2537
+ @SessionExpire = sessionexpire
2538
+ @HealthSwitch = healthswitch
2539
+ @TimeOut = timeout
2540
+ @IntervalTime = intervaltime
2541
+ @HealthNum = healthnum
2542
+ @UnhealthNum = unhealthnum
2543
+ @Status = status
2544
+ @AddTimestamp = addtimestamp
2545
+ @CustomHealthSwitch = customhealthswitch
2546
+ @InputType = inputtype
2547
+ @LineSeparatorType = lineseparatortype
2548
+ @HealthRequest = healthrequest
2549
+ @HealthResponse = healthresponse
2550
+ @ToaFlag = toaflag
2551
+ @BalanceMode = balancemode
2552
+ end
2553
+
2554
+ def deserialize(params)
2555
+ @ListenerId = params['ListenerId']
2556
+ @ListenerName = params['ListenerName']
2557
+ @Protocol = params['Protocol']
2558
+ @LoadBalancerPort = params['LoadBalancerPort']
2559
+ @Bandwidth = params['Bandwidth']
2560
+ @ListenerType = params['ListenerType']
2561
+ @SessionExpire = params['SessionExpire']
2562
+ @HealthSwitch = params['HealthSwitch']
2563
+ @TimeOut = params['TimeOut']
2564
+ @IntervalTime = params['IntervalTime']
2565
+ @HealthNum = params['HealthNum']
2566
+ @UnhealthNum = params['UnhealthNum']
2567
+ @Status = params['Status']
2568
+ @AddTimestamp = params['AddTimestamp']
2569
+ @CustomHealthSwitch = params['CustomHealthSwitch']
2570
+ @InputType = params['InputType']
2571
+ @LineSeparatorType = params['LineSeparatorType']
2572
+ @HealthRequest = params['HealthRequest']
2573
+ @HealthResponse = params['HealthResponse']
2574
+ @ToaFlag = params['ToaFlag']
2575
+ @BalanceMode = params['BalanceMode']
2576
+ end
2577
+ end
2578
+
2579
+ # 获取七层转发路径绑定的主机列表时返回的主机信息。
2580
+ class L7Backend < TencentCloud::Common::AbstractModel
2581
+ # @param BindType: 绑定类别(0代表黑石物理机,1代表虚拟机IP)。
2582
+ # @type BindType: Integer
2583
+ # @param Port: 主机端口。
2584
+ # @type Port: Integer
2585
+ # @param Weight: 权重。
2586
+ # @type Weight: Integer
2587
+ # @param Status: 当前绑定关系的健康检查状态(Dead代表不健康,Alive代表健康)。
2588
+ # @type Status: String
2589
+ # @param InstanceId: 黑石物理机的主机ID。
2590
+ # @type InstanceId: String
2591
+ # @param Alias: 黑石物理机的别名。
2592
+ # @type Alias: String
2593
+ # @param LanIp: 主机IP。
2594
+ # @type LanIp: String
2595
+ # @param MgtIp: 黑石物理机的管理IP。
2596
+ # @type MgtIp: String
2597
+ # @param Operates: 黑石物理机当前可以执行的操作。
2598
+ # @type Operates: Array
2599
+
2600
+ attr_accessor :BindType, :Port, :Weight, :Status, :InstanceId, :Alias, :LanIp, :MgtIp, :Operates
2601
+
2602
+ def initialize(bindtype=nil, port=nil, weight=nil, status=nil, instanceid=nil, _alias=nil, lanip=nil, mgtip=nil, operates=nil)
2603
+ @BindType = bindtype
2604
+ @Port = port
2605
+ @Weight = weight
2606
+ @Status = status
2607
+ @InstanceId = instanceid
2608
+ @Alias = _alias
2609
+ @LanIp = lanip
2610
+ @MgtIp = mgtip
2611
+ @Operates = operates
2612
+ end
2613
+
2614
+ def deserialize(params)
2615
+ @BindType = params['BindType']
2616
+ @Port = params['Port']
2617
+ @Weight = params['Weight']
2618
+ @Status = params['Status']
2619
+ @InstanceId = params['InstanceId']
2620
+ @Alias = params['Alias']
2621
+ @LanIp = params['LanIp']
2622
+ @MgtIp = params['MgtIp']
2623
+ @Operates = params['Operates']
2624
+ end
2625
+ end
2626
+
2627
+ # 监听器信息。
2628
+ class L7ExListener < TencentCloud::Common::AbstractModel
2629
+ # @param ListenerId: 绑定的监听器唯一ID。
2630
+ # @type ListenerId: String
2631
+ # @param ListenerName: 监听器名称。
2632
+ # @type ListenerName: String
2633
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
2634
+ # @type Protocol: String
2635
+ # @param LoadBalancerPort: 监听器的监听端口。
2636
+ # @type LoadBalancerPort: Integer
2637
+ # @param Bandwidth: 当前带宽。
2638
+ # @type Bandwidth: Integer
2639
+ # @param MaxBandwidth: 带宽上限。
2640
+ # @type MaxBandwidth: Integer
2641
+ # @param ListenerType: 监听器类型。
2642
+ # @type ListenerType: String
2643
+ # @param SslMode: 认证方式:0(不认证,用于http),1(单向认证,用于https),2(双向认证,用于https)。
2644
+ # @type SslMode: Integer
2645
+ # @param CertId: 服务端证书ID。
2646
+ # @type CertId: String
2647
+ # @param CertCaId: 客户端证书ID。
2648
+ # @type CertCaId: String
2649
+ # @param AddTimestamp: 添加时间。
2650
+ # @type AddTimestamp: String
2651
+ # @param LoadBalancerId: 负载均衡名ID。
2652
+ # @type LoadBalancerId: String
2653
+ # @param VpcName: 私有网络名称。
2654
+ # @type VpcName: String
2655
+ # @param VpcCidrBlock: 私有网络Cidr。
2656
+ # @type VpcCidrBlock: String
2657
+ # @param LoadBalancerVips: 负载均衡的VIP。
2658
+ # @type LoadBalancerVips: Array
2659
+ # @param LoadBalancerName: 负载均衡名称。
2660
+ # @type LoadBalancerName: String
2661
+ # @param LoadBalancerVipv6s: 负载均衡IPV6的VIP。
2662
+ # @type LoadBalancerVipv6s: Array
2663
+ # @param IpProtocolType: 支持的IP协议类型。ipv4或者是ipv6。
2664
+ # @type IpProtocolType: String
2665
+ # @param BindTrafficMirror: 是否绑定在入参指定的流量镜像中。
2666
+ # @type BindTrafficMirror: Boolean
2667
+
2668
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :MaxBandwidth, :ListenerType, :SslMode, :CertId, :CertCaId, :AddTimestamp, :LoadBalancerId, :VpcName, :VpcCidrBlock, :LoadBalancerVips, :LoadBalancerName, :LoadBalancerVipv6s, :IpProtocolType, :BindTrafficMirror
2669
+
2670
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, maxbandwidth=nil, listenertype=nil, sslmode=nil, certid=nil, certcaid=nil, addtimestamp=nil, loadbalancerid=nil, vpcname=nil, vpccidrblock=nil, loadbalancervips=nil, loadbalancername=nil, loadbalancervipv6s=nil, ipprotocoltype=nil, bindtrafficmirror=nil)
2671
+ @ListenerId = listenerid
2672
+ @ListenerName = listenername
2673
+ @Protocol = protocol
2674
+ @LoadBalancerPort = loadbalancerport
2675
+ @Bandwidth = bandwidth
2676
+ @MaxBandwidth = maxbandwidth
2677
+ @ListenerType = listenertype
2678
+ @SslMode = sslmode
2679
+ @CertId = certid
2680
+ @CertCaId = certcaid
2681
+ @AddTimestamp = addtimestamp
2682
+ @LoadBalancerId = loadbalancerid
2683
+ @VpcName = vpcname
2684
+ @VpcCidrBlock = vpccidrblock
2685
+ @LoadBalancerVips = loadbalancervips
2686
+ @LoadBalancerName = loadbalancername
2687
+ @LoadBalancerVipv6s = loadbalancervipv6s
2688
+ @IpProtocolType = ipprotocoltype
2689
+ @BindTrafficMirror = bindtrafficmirror
2690
+ end
2691
+
2692
+ def deserialize(params)
2693
+ @ListenerId = params['ListenerId']
2694
+ @ListenerName = params['ListenerName']
2695
+ @Protocol = params['Protocol']
2696
+ @LoadBalancerPort = params['LoadBalancerPort']
2697
+ @Bandwidth = params['Bandwidth']
2698
+ @MaxBandwidth = params['MaxBandwidth']
2699
+ @ListenerType = params['ListenerType']
2700
+ @SslMode = params['SslMode']
2701
+ @CertId = params['CertId']
2702
+ @CertCaId = params['CertCaId']
2703
+ @AddTimestamp = params['AddTimestamp']
2704
+ @LoadBalancerId = params['LoadBalancerId']
2705
+ @VpcName = params['VpcName']
2706
+ @VpcCidrBlock = params['VpcCidrBlock']
2707
+ @LoadBalancerVips = params['LoadBalancerVips']
2708
+ @LoadBalancerName = params['LoadBalancerName']
2709
+ @LoadBalancerVipv6s = params['LoadBalancerVipv6s']
2710
+ @IpProtocolType = params['IpProtocolType']
2711
+ @BindTrafficMirror = params['BindTrafficMirror']
2712
+ end
2713
+ end
2714
+
2715
+ # 获取黑石负载均衡七层监听器时返回的七层监听器信息。
2716
+ class L7Listener < TencentCloud::Common::AbstractModel
2717
+ # @param ListenerId: 七层监听器实例ID。
2718
+ # @type ListenerId: String
2719
+ # @param ListenerName: 七层监听器名称。
2720
+ # @type ListenerName: String
2721
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
2722
+ # @type Protocol: String
2723
+ # @param LoadBalancerPort: 七层监听器的监听端口。
2724
+ # @type LoadBalancerPort: Integer
2725
+ # @param Bandwidth: 计费模式为按固定带宽方式时监听器的限速值,单位:Mbps。
2726
+ # @type Bandwidth: Integer
2727
+ # @param ListenerType: 监听器的类别:L4Listener(四层监听器),L7Listener(七层监听器)。
2728
+ # @type ListenerType: String
2729
+ # @param SslMode: 七层监听器的认证方式:0(不认证,用于http),1(单向认证,用于https),2(双向认证,用于https)。
2730
+ # @type SslMode: Integer
2731
+ # @param CertId: 七层监听器关联的服务端证书ID。
2732
+ # @type CertId: String
2733
+ # @param CertCaId: 七层监听器关联的客户端证书ID。
2734
+ # @type CertCaId: String
2735
+ # @param Status: 监听器当前状态(0代表创建中,1代表正常运行,2代表创建失败,3代表删除中,4代表删除失败)。
2736
+ # @type Status: Integer
2737
+ # @param AddTimestamp: 创建时间戳。
2738
+ # @type AddTimestamp: String
2739
+ # @param ForwardProtocol: https转发类型。0:https。1:spdy。2:http2。3:spdy+http2。
2740
+ # @type ForwardProtocol: Integer
2741
+
2742
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :ListenerType, :SslMode, :CertId, :CertCaId, :Status, :AddTimestamp, :ForwardProtocol
2743
+
2744
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, listenertype=nil, sslmode=nil, certid=nil, certcaid=nil, status=nil, addtimestamp=nil, forwardprotocol=nil)
2745
+ @ListenerId = listenerid
2746
+ @ListenerName = listenername
2747
+ @Protocol = protocol
2748
+ @LoadBalancerPort = loadbalancerport
2749
+ @Bandwidth = bandwidth
2750
+ @ListenerType = listenertype
2751
+ @SslMode = sslmode
2752
+ @CertId = certid
2753
+ @CertCaId = certcaid
2754
+ @Status = status
2755
+ @AddTimestamp = addtimestamp
2756
+ @ForwardProtocol = forwardprotocol
2757
+ end
2758
+
2759
+ def deserialize(params)
2760
+ @ListenerId = params['ListenerId']
2761
+ @ListenerName = params['ListenerName']
2762
+ @Protocol = params['Protocol']
2763
+ @LoadBalancerPort = params['LoadBalancerPort']
2764
+ @Bandwidth = params['Bandwidth']
2765
+ @ListenerType = params['ListenerType']
2766
+ @SslMode = params['SslMode']
2767
+ @CertId = params['CertId']
2768
+ @CertCaId = params['CertCaId']
2769
+ @Status = params['Status']
2770
+ @AddTimestamp = params['AddTimestamp']
2771
+ @ForwardProtocol = params['ForwardProtocol']
2772
+ end
2773
+ end
2774
+
2775
+ # 查询绑定了某主机的七层监听器时返回的七层监听器信息。
2776
+ class L7ListenerInfo < TencentCloud::Common::AbstractModel
2777
+ # @param ListenerId: 七层监听器实例ID。
2778
+ # @type ListenerId: String
2779
+ # @param ListenerName: 七层监听器名称。
2780
+ # @type ListenerName: String
2781
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
2782
+ # @type Protocol: String
2783
+ # @param LoadBalancerPort: 七层监听器的监听端口。
2784
+ # @type LoadBalancerPort: Integer
2785
+ # @param Bandwidth: 计费模式为按固定带宽方式时监听器的限速值,单位:Mbps。
2786
+ # @type Bandwidth: Integer
2787
+ # @param ListenerType: 监听器的类别:L4Listener(四层监听器),L7Listener(七层监听器)。
2788
+ # @type ListenerType: String
2789
+ # @param SslMode: 七层监听器的认证方式:0(不认证,用于http),1(单向认证,用于https),2(双向认证,用于https)。
2790
+ # @type SslMode: Integer
2791
+ # @param CertId: 七层监听器关联的服务端证书ID。
2792
+ # @type CertId: String
2793
+ # @param CertCaId: 七层监听器关联的客户端证书ID。
2794
+ # @type CertCaId: String
2795
+ # @param Status: 当前绑定关系的健康检查状态(Dead代表不健康,Alive代表健康)。
2796
+ # @type Status: Integer
2797
+ # @param AddTimestamp: 创建时间戳。
2798
+ # @type AddTimestamp: String
2799
+ # @param RuleSet: 返回的转发规则列表。
2800
+ # @type RuleSet: Array
2801
+ # @param ForwardProtocol: https转发类型。0:https。1:spdy。2:http2。3:spdy+http2。
2802
+ # @type ForwardProtocol: Integer
2803
+
2804
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :ListenerType, :SslMode, :CertId, :CertCaId, :Status, :AddTimestamp, :RuleSet, :ForwardProtocol
2805
+
2806
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, listenertype=nil, sslmode=nil, certid=nil, certcaid=nil, status=nil, addtimestamp=nil, ruleset=nil, forwardprotocol=nil)
2807
+ @ListenerId = listenerid
2808
+ @ListenerName = listenername
2809
+ @Protocol = protocol
2810
+ @LoadBalancerPort = loadbalancerport
2811
+ @Bandwidth = bandwidth
2812
+ @ListenerType = listenertype
2813
+ @SslMode = sslmode
2814
+ @CertId = certid
2815
+ @CertCaId = certcaid
2816
+ @Status = status
2817
+ @AddTimestamp = addtimestamp
2818
+ @RuleSet = ruleset
2819
+ @ForwardProtocol = forwardprotocol
2820
+ end
2821
+
2822
+ def deserialize(params)
2823
+ @ListenerId = params['ListenerId']
2824
+ @ListenerName = params['ListenerName']
2825
+ @Protocol = params['Protocol']
2826
+ @LoadBalancerPort = params['LoadBalancerPort']
2827
+ @Bandwidth = params['Bandwidth']
2828
+ @ListenerType = params['ListenerType']
2829
+ @SslMode = params['SslMode']
2830
+ @CertId = params['CertId']
2831
+ @CertCaId = params['CertCaId']
2832
+ @Status = params['Status']
2833
+ @AddTimestamp = params['AddTimestamp']
2834
+ unless params['RuleSet'].nil?
2835
+ @RuleSet = []
2836
+ params['RuleSet'].each do |i|
2837
+ l7listenerinforule_tmp = L7ListenerInfoRule.new
2838
+ l7listenerinforule_tmp.deserialize(i)
2839
+ @RuleSet << l7listenerinforule_tmp
2840
+ end
2841
+ end
2842
+ @ForwardProtocol = params['ForwardProtocol']
2843
+ end
2844
+ end
2845
+
2846
+ # 查询绑定了某主机七层监听器时返回的与转发路径所绑定的主机信息。
2847
+ class L7ListenerInfoBackend < TencentCloud::Common::AbstractModel
2848
+ # @param BindType: 绑定类别(0代表黑石物理机,1代表虚拟机IP)。
2849
+ # @type BindType: Integer
2850
+ # @param Port: 主机端口。
2851
+ # @type Port: Integer
2852
+ # @param Weight: 权重。
2853
+ # @type Weight: Integer
2854
+ # @param Status: 当前绑定关系的健康检查状态(Dead代表不健康,Alive代表健康)。
2855
+ # @type Status: String
2856
+ # @param InstanceId: 黑石物理机的主机ID。
2857
+ # @type InstanceId: String
2858
+ # @param Alias: 黑石物理机的别名。
2859
+ # @type Alias: String
2860
+ # @param LanIp: 主机IP。
2861
+ # @type LanIp: String
2862
+
2863
+ attr_accessor :BindType, :Port, :Weight, :Status, :InstanceId, :Alias, :LanIp
2864
+
2865
+ def initialize(bindtype=nil, port=nil, weight=nil, status=nil, instanceid=nil, _alias=nil, lanip=nil)
2866
+ @BindType = bindtype
2867
+ @Port = port
2868
+ @Weight = weight
2869
+ @Status = status
2870
+ @InstanceId = instanceid
2871
+ @Alias = _alias
2872
+ @LanIp = lanip
2873
+ end
2874
+
2875
+ def deserialize(params)
2876
+ @BindType = params['BindType']
2877
+ @Port = params['Port']
2878
+ @Weight = params['Weight']
2879
+ @Status = params['Status']
2880
+ @InstanceId = params['InstanceId']
2881
+ @Alias = params['Alias']
2882
+ @LanIp = params['LanIp']
2883
+ end
2884
+ end
2885
+
2886
+ # 查询绑定了某主机的七层监听器时返回的转发路径。
2887
+ class L7ListenerInfoLocation < TencentCloud::Common::AbstractModel
2888
+ # @param Url: 转发路径。
2889
+ # @type Url: String
2890
+ # @param LocationId: 转发路径实例ID。
2891
+ # @type LocationId: String
2892
+ # @param SessionExpire: 会话保持时间。
2893
+ # @type SessionExpire: Integer
2894
+ # @param HealthSwitch: 是否开启健康检查。
2895
+ # @type HealthSwitch: Integer
2896
+ # @param HttpCheckPath: 健康检查检查路径。
2897
+ # @type HttpCheckPath: String
2898
+ # @param HttpCheckDomain: 健康检查检查域名。
2899
+ # @type HttpCheckDomain: String
2900
+ # @param IntervalTime: 健康检查检查间隔时间。
2901
+ # @type IntervalTime: Integer
2902
+ # @param HealthNum: 健康检查健康阈值。
2903
+ # @type HealthNum: Integer
2904
+ # @param UnhealthNum: 健康检查不健康阈值。
2905
+ # @type UnhealthNum: Integer
2906
+ # @param HttpCodes: 健康检查中认为健康的HTTP返回码的组合。可选值为1~5的集合,1表示HTTP返回码为1xx认为健康。2表示HTTP返回码为2xx认为健康。3表示HTTP返回码为3xx认为健康。4表示HTTP返回码为4xx认为健康。5表示HTTP返回码为5xx认为健康。
2907
+ # @type HttpCodes: Array
2908
+ # @param BalanceMode: 均衡方式。
2909
+ # @type BalanceMode: String
2910
+ # @param Status: 当前绑定关系的健康检查状态(Dead代表不健康,Alive代表健康)。
2911
+ # @type Status: Integer
2912
+ # @param AddTimestamp: 创建时间戳。
2913
+ # @type AddTimestamp: String
2914
+ # @param BackendSet: 该转发路径所绑定的主机列表。
2915
+ # @type BackendSet: Array
2916
+
2917
+ attr_accessor :Url, :LocationId, :SessionExpire, :HealthSwitch, :HttpCheckPath, :HttpCheckDomain, :IntervalTime, :HealthNum, :UnhealthNum, :HttpCodes, :BalanceMode, :Status, :AddTimestamp, :BackendSet
2918
+
2919
+ def initialize(url=nil, locationid=nil, sessionexpire=nil, healthswitch=nil, httpcheckpath=nil, httpcheckdomain=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, httpcodes=nil, balancemode=nil, status=nil, addtimestamp=nil, backendset=nil)
2920
+ @Url = url
2921
+ @LocationId = locationid
2922
+ @SessionExpire = sessionexpire
2923
+ @HealthSwitch = healthswitch
2924
+ @HttpCheckPath = httpcheckpath
2925
+ @HttpCheckDomain = httpcheckdomain
2926
+ @IntervalTime = intervaltime
2927
+ @HealthNum = healthnum
2928
+ @UnhealthNum = unhealthnum
2929
+ @HttpCodes = httpcodes
2930
+ @BalanceMode = balancemode
2931
+ @Status = status
2932
+ @AddTimestamp = addtimestamp
2933
+ @BackendSet = backendset
2934
+ end
2935
+
2936
+ def deserialize(params)
2937
+ @Url = params['Url']
2938
+ @LocationId = params['LocationId']
2939
+ @SessionExpire = params['SessionExpire']
2940
+ @HealthSwitch = params['HealthSwitch']
2941
+ @HttpCheckPath = params['HttpCheckPath']
2942
+ @HttpCheckDomain = params['HttpCheckDomain']
2943
+ @IntervalTime = params['IntervalTime']
2944
+ @HealthNum = params['HealthNum']
2945
+ @UnhealthNum = params['UnhealthNum']
2946
+ @HttpCodes = params['HttpCodes']
2947
+ @BalanceMode = params['BalanceMode']
2948
+ @Status = params['Status']
2949
+ @AddTimestamp = params['AddTimestamp']
2950
+ unless params['BackendSet'].nil?
2951
+ @BackendSet = []
2952
+ params['BackendSet'].each do |i|
2953
+ l7listenerinfobackend_tmp = L7ListenerInfoBackend.new
2954
+ l7listenerinfobackend_tmp.deserialize(i)
2955
+ @BackendSet << l7listenerinfobackend_tmp
2956
+ end
2957
+ end
2958
+ end
2959
+ end
2960
+
2961
+ # 查询绑定了某主机的七层监听器时返回的转发规则。
2962
+ class L7ListenerInfoRule < TencentCloud::Common::AbstractModel
2963
+ # @param Domain: 转发域名。
2964
+ # @type Domain: String
2965
+ # @param DomainId: 转发域名实例ID。
2966
+ # @type DomainId: String
2967
+ # @param Status: 当前绑定关系的健康检查状态(Dead代表不健康,Alive代表健康)。
2968
+ # @type Status: Integer
2969
+ # @param AddTimestamp: 创建时间戳。
2970
+ # @type AddTimestamp: String
2971
+ # @param LocationSet: 该转发域名下面的转发路径列表。
2972
+ # @type LocationSet: Array
2973
+
2974
+ attr_accessor :Domain, :DomainId, :Status, :AddTimestamp, :LocationSet
2975
+
2976
+ def initialize(domain=nil, domainid=nil, status=nil, addtimestamp=nil, locationset=nil)
2977
+ @Domain = domain
2978
+ @DomainId = domainid
2979
+ @Status = status
2980
+ @AddTimestamp = addtimestamp
2981
+ @LocationSet = locationset
2982
+ end
2983
+
2984
+ def deserialize(params)
2985
+ @Domain = params['Domain']
2986
+ @DomainId = params['DomainId']
2987
+ @Status = params['Status']
2988
+ @AddTimestamp = params['AddTimestamp']
2989
+ unless params['LocationSet'].nil?
2990
+ @LocationSet = []
2991
+ params['LocationSet'].each do |i|
2992
+ l7listenerinfolocation_tmp = L7ListenerInfoLocation.new
2993
+ l7listenerinfolocation_tmp.deserialize(i)
2994
+ @LocationSet << l7listenerinfolocation_tmp
2995
+ end
2996
+ end
2997
+ end
2998
+ end
2999
+
3000
+ # 获取七层监听器转发规则时返回的转发规则。
3001
+ class L7Rule < TencentCloud::Common::AbstractModel
3002
+ # @param Domain: 转发域名。
3003
+ # @type Domain: String
3004
+ # @param DomainId: 转发域名实例ID。
3005
+ # @type DomainId: String
3006
+ # @param Status: 转发路径当前状态(0代表创建中,1代表正常运行,2代表创建失败,3代表删除中,4代表删除失败)。
3007
+ # @type Status: Integer
3008
+ # @param AddTimestamp: 创建时间戳。
3009
+ # @type AddTimestamp: String
3010
+ # @param LocationSet: 该转发域名下面的转发路径列表。
3011
+ # @type LocationSet: Array
3012
+
3013
+ attr_accessor :Domain, :DomainId, :Status, :AddTimestamp, :LocationSet
3014
+
3015
+ def initialize(domain=nil, domainid=nil, status=nil, addtimestamp=nil, locationset=nil)
3016
+ @Domain = domain
3017
+ @DomainId = domainid
3018
+ @Status = status
3019
+ @AddTimestamp = addtimestamp
3020
+ @LocationSet = locationset
3021
+ end
3022
+
3023
+ def deserialize(params)
3024
+ @Domain = params['Domain']
3025
+ @DomainId = params['DomainId']
3026
+ @Status = params['Status']
3027
+ @AddTimestamp = params['AddTimestamp']
3028
+ unless params['LocationSet'].nil?
3029
+ @LocationSet = []
3030
+ params['LocationSet'].each do |i|
3031
+ l7ruleslocation_tmp = L7RulesLocation.new
3032
+ l7ruleslocation_tmp.deserialize(i)
3033
+ @LocationSet << l7ruleslocation_tmp
3034
+ end
3035
+ end
3036
+ end
3037
+ end
3038
+
3039
+ # 获取七层转发规则时返回的转发域名下面的转发路径。
3040
+ class L7RulesLocation < TencentCloud::Common::AbstractModel
3041
+ # @param Url: 转发路径。
3042
+ # @type Url: String
3043
+ # @param LocationId: 转发路径实例ID。
3044
+ # @type LocationId: String
3045
+ # @param SessionExpire: 会话保持时间。
3046
+ # @type SessionExpire: Integer
3047
+ # @param HealthSwitch: 是否开启健康检查。
3048
+ # @type HealthSwitch: Integer
3049
+ # @param HttpCheckPath: 健康检查检查路径。
3050
+ # @type HttpCheckPath: String
3051
+ # @param HttpCheckDomain: 健康检查检查域名。
3052
+ # @type HttpCheckDomain: String
3053
+ # @param IntervalTime: 健康检查检查间隔时间。
3054
+ # @type IntervalTime: Integer
3055
+ # @param HealthNum: 健康检查健康阈值。
3056
+ # @type HealthNum: Integer
3057
+ # @param UnhealthNum: 健康检查不健康阈值。
3058
+ # @type UnhealthNum: Integer
3059
+ # @param HttpCodes: 健康检查中认为健康的HTTP返回码的组合。可选值为1~5的集合,1表示HTTP返回码为1xx认为健康。2表示HTTP返回码为2xx认为健康。3表示HTTP返回码为3xx认为健康。4表示HTTP返回码为4xx认为健康。5表示HTTP返回码为5xx认为健康。
3060
+ # @type HttpCodes: Array
3061
+ # @param BalanceMode: 均衡方式。
3062
+ # @type BalanceMode: String
3063
+ # @param Status: 转发路径当前状态(0代表创建中,1代表正常运行,2代表创建失败,3代表删除中,4代表删除失败)。
3064
+ # @type Status: Integer
3065
+ # @param AddTimestamp: 创建时间戳。
3066
+ # @type AddTimestamp: String
3067
+
3068
+ attr_accessor :Url, :LocationId, :SessionExpire, :HealthSwitch, :HttpCheckPath, :HttpCheckDomain, :IntervalTime, :HealthNum, :UnhealthNum, :HttpCodes, :BalanceMode, :Status, :AddTimestamp
3069
+
3070
+ def initialize(url=nil, locationid=nil, sessionexpire=nil, healthswitch=nil, httpcheckpath=nil, httpcheckdomain=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, httpcodes=nil, balancemode=nil, status=nil, addtimestamp=nil)
3071
+ @Url = url
3072
+ @LocationId = locationid
3073
+ @SessionExpire = sessionexpire
3074
+ @HealthSwitch = healthswitch
3075
+ @HttpCheckPath = httpcheckpath
3076
+ @HttpCheckDomain = httpcheckdomain
3077
+ @IntervalTime = intervaltime
3078
+ @HealthNum = healthnum
3079
+ @UnhealthNum = unhealthnum
3080
+ @HttpCodes = httpcodes
3081
+ @BalanceMode = balancemode
3082
+ @Status = status
3083
+ @AddTimestamp = addtimestamp
3084
+ end
3085
+
3086
+ def deserialize(params)
3087
+ @Url = params['Url']
3088
+ @LocationId = params['LocationId']
3089
+ @SessionExpire = params['SessionExpire']
3090
+ @HealthSwitch = params['HealthSwitch']
3091
+ @HttpCheckPath = params['HttpCheckPath']
3092
+ @HttpCheckDomain = params['HttpCheckDomain']
3093
+ @IntervalTime = params['IntervalTime']
3094
+ @HealthNum = params['HealthNum']
3095
+ @UnhealthNum = params['UnhealthNum']
3096
+ @HttpCodes = params['HttpCodes']
3097
+ @BalanceMode = params['BalanceMode']
3098
+ @Status = params['Status']
3099
+ @AddTimestamp = params['AddTimestamp']
3100
+ end
3101
+ end
3102
+
3103
+ # 获取负载均衡实例列表时返回的负载均衡信息。
3104
+ class LoadBalancer < TencentCloud::Common::AbstractModel
3105
+ # @param LoadBalancerId: 负载均衡器ID
3106
+ # @type LoadBalancerId: String
3107
+ # @param ProjectId: 项目ID,通过v2/DescribeProject 接口获得
3108
+ # @type ProjectId: Integer
3109
+ # @param LoadBalancerName: 负载均衡器名称
3110
+ # @type LoadBalancerName: String
3111
+ # @param LoadBalancerType: 负载均衡的类型 : open表示公网负载均衡类型,internal表示内网负载均衡类型
3112
+ # @type LoadBalancerType: String
3113
+ # @param Exclusive: 是否筛选独占集群,0表示非独占集群,1表示四层独占集群,2表示七层独占集群,3表示四层和七层独占集群,4表示共享容灾
3114
+ # @type Exclusive: Integer
3115
+ # @param TgwSetType: 该负载均衡对应的tgw集群(fullnat,tunnel,dnat)
3116
+ # @type TgwSetType: String
3117
+ # @param Domain: 负载均衡域名。规则:1-60个小写英文字母、数字、点号“.”或连接线“-”。内网类型的负载均衡不能配置该字段
3118
+ # @type Domain: String
3119
+ # @param VpcId: 该负载均衡对应的所在的VpcId
3120
+ # @type VpcId: String
3121
+ # @param SubnetId: 该负载均衡对应的所在的SubnetId
3122
+ # @type SubnetId: String
3123
+ # @param Status: 无
3124
+ # @type Status: Integer
3125
+ # @param PayMode: 无
3126
+ # @type PayMode: String
3127
+ # @param LatestPayMode: 无
3128
+ # @type LatestPayMode: String
3129
+ # @param CreateTime: 无
3130
+ # @type CreateTime: String
3131
+ # @param StatusTime: 无
3132
+ # @type StatusTime: String
3133
+ # @param VpcName: 私有网络名称。
3134
+ # @type VpcName: String
3135
+ # @param VpcCidrBlock: 私有网络Cidr。
3136
+ # @type VpcCidrBlock: String
3137
+ # @param LoadBalancerVips: 负载均衡的IPV4的VIP。
3138
+ # @type LoadBalancerVips: Array
3139
+ # @param SupportListenerTypes: 无
3140
+ # @type SupportListenerTypes: Array
3141
+ # @param Bandwidth: 无
3142
+ # @type Bandwidth: Integer
3143
+ # @param ConfId: 负载均衡个性化配置ID
3144
+ # @type ConfId: String
3145
+ # @param ConfName: 无
3146
+ # @type ConfName: String
3147
+ # @param LoadBalancerVipv6s: 负载均衡的IPV6的VIP。
3148
+ # @type LoadBalancerVipv6s: Array
3149
+ # @param IpProtocolType: 负载均衡IP协议类型。ipv4或者ipv6。
3150
+ # @type IpProtocolType: String
3151
+ # @param BzPayMode: 保障型网关计费形式
3152
+ # @type BzPayMode: String
3153
+ # @param BzL4Metrics: 保障型网关四层计费指标
3154
+ # @type BzL4Metrics: String
3155
+ # @param BzL7Metrics: 保障型网关七层计费指标
3156
+ # @type BzL7Metrics: String
3157
+ # @param IntVpcId: 该负载均衡对应的所在的整形类型的VpcId
3158
+ # @type IntVpcId: Integer
3159
+ # @param CurVips: 负载均衡的IPV6或者IPV4的VIP。
3160
+ # 注意:此字段可能返回 null,表示取不到有效值。
3161
+ # @type CurVips: Array
3162
+
3163
+ attr_accessor :LoadBalancerId, :ProjectId, :LoadBalancerName, :LoadBalancerType, :Exclusive, :TgwSetType, :Domain, :VpcId, :SubnetId, :Status, :PayMode, :LatestPayMode, :CreateTime, :StatusTime, :VpcName, :VpcCidrBlock, :LoadBalancerVips, :SupportListenerTypes, :Bandwidth, :ConfId, :ConfName, :LoadBalancerVipv6s, :IpProtocolType, :BzPayMode, :BzL4Metrics, :BzL7Metrics, :IntVpcId, :CurVips
3164
+
3165
+ def initialize(loadbalancerid=nil, projectid=nil, loadbalancername=nil, loadbalancertype=nil, exclusive=nil, tgwsettype=nil, domain=nil, vpcid=nil, subnetid=nil, status=nil, paymode=nil, latestpaymode=nil, createtime=nil, statustime=nil, vpcname=nil, vpccidrblock=nil, loadbalancervips=nil, supportlistenertypes=nil, bandwidth=nil, confid=nil, confname=nil, loadbalancervipv6s=nil, ipprotocoltype=nil, bzpaymode=nil, bzl4metrics=nil, bzl7metrics=nil, intvpcid=nil, curvips=nil)
3166
+ @LoadBalancerId = loadbalancerid
3167
+ @ProjectId = projectid
3168
+ @LoadBalancerName = loadbalancername
3169
+ @LoadBalancerType = loadbalancertype
3170
+ @Exclusive = exclusive
3171
+ @TgwSetType = tgwsettype
3172
+ @Domain = domain
3173
+ @VpcId = vpcid
3174
+ @SubnetId = subnetid
3175
+ @Status = status
3176
+ @PayMode = paymode
3177
+ @LatestPayMode = latestpaymode
3178
+ @CreateTime = createtime
3179
+ @StatusTime = statustime
3180
+ @VpcName = vpcname
3181
+ @VpcCidrBlock = vpccidrblock
3182
+ @LoadBalancerVips = loadbalancervips
3183
+ @SupportListenerTypes = supportlistenertypes
3184
+ @Bandwidth = bandwidth
3185
+ @ConfId = confid
3186
+ @ConfName = confname
3187
+ @LoadBalancerVipv6s = loadbalancervipv6s
3188
+ @IpProtocolType = ipprotocoltype
3189
+ @BzPayMode = bzpaymode
3190
+ @BzL4Metrics = bzl4metrics
3191
+ @BzL7Metrics = bzl7metrics
3192
+ @IntVpcId = intvpcid
3193
+ @CurVips = curvips
3194
+ end
3195
+
3196
+ def deserialize(params)
3197
+ @LoadBalancerId = params['LoadBalancerId']
3198
+ @ProjectId = params['ProjectId']
3199
+ @LoadBalancerName = params['LoadBalancerName']
3200
+ @LoadBalancerType = params['LoadBalancerType']
3201
+ @Exclusive = params['Exclusive']
3202
+ @TgwSetType = params['TgwSetType']
3203
+ @Domain = params['Domain']
3204
+ @VpcId = params['VpcId']
3205
+ @SubnetId = params['SubnetId']
3206
+ @Status = params['Status']
3207
+ @PayMode = params['PayMode']
3208
+ @LatestPayMode = params['LatestPayMode']
3209
+ @CreateTime = params['CreateTime']
3210
+ @StatusTime = params['StatusTime']
3211
+ @VpcName = params['VpcName']
3212
+ @VpcCidrBlock = params['VpcCidrBlock']
3213
+ @LoadBalancerVips = params['LoadBalancerVips']
3214
+ @SupportListenerTypes = params['SupportListenerTypes']
3215
+ @Bandwidth = params['Bandwidth']
3216
+ @ConfId = params['ConfId']
3217
+ @ConfName = params['ConfName']
3218
+ @LoadBalancerVipv6s = params['LoadBalancerVipv6s']
3219
+ @IpProtocolType = params['IpProtocolType']
3220
+ @BzPayMode = params['BzPayMode']
3221
+ @BzL4Metrics = params['BzL4Metrics']
3222
+ @BzL7Metrics = params['BzL7Metrics']
3223
+ @IntVpcId = params['IntVpcId']
3224
+ @CurVips = params['CurVips']
3225
+ end
3226
+ end
3227
+
3228
+ # 获取黑石负载均衡端口相关信息时返回的监听器信息(四层和七层)。
3229
+ class LoadBalancerPortInfoListener < TencentCloud::Common::AbstractModel
3230
+ # @param ListenerId: 负载均衡监听器ID。
3231
+ # @type ListenerId: String
3232
+ # @param ListenerName: 监听器名称。
3233
+ # @type ListenerName: String
3234
+ # @param Protocol: 监听器协议类型,可选值:http,https,tcp,udp。
3235
+ # @type Protocol: String
3236
+ # @param LoadBalancerPort: 监听器的监听端口。
3237
+ # @type LoadBalancerPort: Integer
3238
+ # @param Bandwidth: 计费模式为按固定带宽方式时监听器的限速值,单位:Mbps。
3239
+ # @type Bandwidth: Integer
3240
+ # @param Status: 监听器当前状态(0代表创建中,1代表正常运行,2代表创建失败,3代表删除中,4代表删除失败)。
3241
+ # @type Status: Integer
3242
+ # @param Port: 与监听器绑定的主机端口。
3243
+ # @type Port: Integer
3244
+
3245
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :Status, :Port
3246
+
3247
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, status=nil, port=nil)
3248
+ @ListenerId = listenerid
3249
+ @ListenerName = listenername
3250
+ @Protocol = protocol
3251
+ @LoadBalancerPort = loadbalancerport
3252
+ @Bandwidth = bandwidth
3253
+ @Status = status
3254
+ @Port = port
3255
+ end
3256
+
3257
+ def deserialize(params)
3258
+ @ListenerId = params['ListenerId']
3259
+ @ListenerName = params['ListenerName']
3260
+ @Protocol = params['Protocol']
3261
+ @LoadBalancerPort = params['LoadBalancerPort']
3262
+ @Bandwidth = params['Bandwidth']
3263
+ @Status = params['Status']
3264
+ @Port = params['Port']
3265
+ end
3266
+ end
3267
+
3268
+ # ModifyL4BackendPort请求参数结构体
3269
+ class ModifyL4BackendPortRequest < TencentCloud::Common::AbstractModel
3270
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3271
+ # @type LoadBalancerId: String
3272
+ # @param ListenerId: 负载均衡四层监听器ID,可通过接口DescribeL4Listeners查询。
3273
+ # @type ListenerId: String
3274
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
3275
+ # @type InstanceId: String
3276
+ # @param Port: 已绑定的主机端口。
3277
+ # @type Port: Integer
3278
+ # @param NewPort: 新的主机端口,可选值1~65535。
3279
+ # @type NewPort: Integer
3280
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
3281
+ # @type BindType: Integer
3282
+
3283
+ attr_accessor :LoadBalancerId, :ListenerId, :InstanceId, :Port, :NewPort, :BindType
3284
+
3285
+ def initialize(loadbalancerid=nil, listenerid=nil, instanceid=nil, port=nil, newport=nil, bindtype=nil)
3286
+ @LoadBalancerId = loadbalancerid
3287
+ @ListenerId = listenerid
3288
+ @InstanceId = instanceid
3289
+ @Port = port
3290
+ @NewPort = newport
3291
+ @BindType = bindtype
3292
+ end
3293
+
3294
+ def deserialize(params)
3295
+ @LoadBalancerId = params['LoadBalancerId']
3296
+ @ListenerId = params['ListenerId']
3297
+ @InstanceId = params['InstanceId']
3298
+ @Port = params['Port']
3299
+ @NewPort = params['NewPort']
3300
+ @BindType = params['BindType']
3301
+ end
3302
+ end
3303
+
3304
+ # ModifyL4BackendPort返回参数结构体
3305
+ class ModifyL4BackendPortResponse < TencentCloud::Common::AbstractModel
3306
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果
3307
+ # @type TaskId: String
3308
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3309
+ # @type RequestId: String
3310
+
3311
+ attr_accessor :TaskId, :RequestId
3312
+
3313
+ def initialize(taskid=nil, requestid=nil)
3314
+ @TaskId = taskid
3315
+ @RequestId = requestid
3316
+ end
3317
+
3318
+ def deserialize(params)
3319
+ @TaskId = params['TaskId']
3320
+ @RequestId = params['RequestId']
3321
+ end
3322
+ end
3323
+
3324
+ # ModifyL4BackendProbePort请求参数结构体
3325
+ class ModifyL4BackendProbePortRequest < TencentCloud::Common::AbstractModel
3326
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3327
+ # @type LoadBalancerId: String
3328
+ # @param ListenerId: 负载均衡四层监听器ID,可通过接口DescribeL7Listeners查询。
3329
+ # @type ListenerId: String
3330
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
3331
+ # @type InstanceId: String
3332
+ # @param Port: 已绑定的主机端口。
3333
+ # @type Port: Integer
3334
+ # @param ProbePort: 新的探测端口,可选值1~65535。
3335
+ # @type ProbePort: Integer
3336
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机IP 2:半托管机器
3337
+ # @type BindType: Integer
3338
+
3339
+ attr_accessor :LoadBalancerId, :ListenerId, :InstanceId, :Port, :ProbePort, :BindType
3340
+
3341
+ def initialize(loadbalancerid=nil, listenerid=nil, instanceid=nil, port=nil, probeport=nil, bindtype=nil)
3342
+ @LoadBalancerId = loadbalancerid
3343
+ @ListenerId = listenerid
3344
+ @InstanceId = instanceid
3345
+ @Port = port
3346
+ @ProbePort = probeport
3347
+ @BindType = bindtype
3348
+ end
3349
+
3350
+ def deserialize(params)
3351
+ @LoadBalancerId = params['LoadBalancerId']
3352
+ @ListenerId = params['ListenerId']
3353
+ @InstanceId = params['InstanceId']
3354
+ @Port = params['Port']
3355
+ @ProbePort = params['ProbePort']
3356
+ @BindType = params['BindType']
3357
+ end
3358
+ end
3359
+
3360
+ # ModifyL4BackendProbePort返回参数结构体
3361
+ class ModifyL4BackendProbePortResponse < TencentCloud::Common::AbstractModel
3362
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
3363
+ # @type TaskId: String
3364
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3365
+ # @type RequestId: String
3366
+
3367
+ attr_accessor :TaskId, :RequestId
3368
+
3369
+ def initialize(taskid=nil, requestid=nil)
3370
+ @TaskId = taskid
3371
+ @RequestId = requestid
3372
+ end
3373
+
3374
+ def deserialize(params)
3375
+ @TaskId = params['TaskId']
3376
+ @RequestId = params['RequestId']
3377
+ end
3378
+ end
3379
+
3380
+ # ModifyL4BackendWeight请求参数结构体
3381
+ class ModifyL4BackendWeightRequest < TencentCloud::Common::AbstractModel
3382
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3383
+ # @type LoadBalancerId: String
3384
+ # @param ListenerId: 负载均衡四层监听器ID,可通过接口DescribeL4Listeners查询。
3385
+ # @type ListenerId: String
3386
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
3387
+ # @type InstanceId: String
3388
+ # @param Weight: 权重信息,可选值0~100。
3389
+ # @type Weight: Integer
3390
+ # @param Port: 已绑定的主机端口。
3391
+ # @type Port: Integer
3392
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
3393
+ # @type BindType: Integer
3394
+
3395
+ attr_accessor :LoadBalancerId, :ListenerId, :InstanceId, :Weight, :Port, :BindType
3396
+
3397
+ def initialize(loadbalancerid=nil, listenerid=nil, instanceid=nil, weight=nil, port=nil, bindtype=nil)
3398
+ @LoadBalancerId = loadbalancerid
3399
+ @ListenerId = listenerid
3400
+ @InstanceId = instanceid
3401
+ @Weight = weight
3402
+ @Port = port
3403
+ @BindType = bindtype
3404
+ end
3405
+
3406
+ def deserialize(params)
3407
+ @LoadBalancerId = params['LoadBalancerId']
3408
+ @ListenerId = params['ListenerId']
3409
+ @InstanceId = params['InstanceId']
3410
+ @Weight = params['Weight']
3411
+ @Port = params['Port']
3412
+ @BindType = params['BindType']
3413
+ end
3414
+ end
3415
+
3416
+ # ModifyL4BackendWeight返回参数结构体
3417
+ class ModifyL4BackendWeightResponse < TencentCloud::Common::AbstractModel
3418
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
3419
+ # @type TaskId: String
3420
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3421
+ # @type RequestId: String
3422
+
3423
+ attr_accessor :TaskId, :RequestId
3424
+
3425
+ def initialize(taskid=nil, requestid=nil)
3426
+ @TaskId = taskid
3427
+ @RequestId = requestid
3428
+ end
3429
+
3430
+ def deserialize(params)
3431
+ @TaskId = params['TaskId']
3432
+ @RequestId = params['RequestId']
3433
+ end
3434
+ end
3435
+
3436
+ # ModifyL4Listener请求参数结构体
3437
+ class ModifyL4ListenerRequest < TencentCloud::Common::AbstractModel
3438
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3439
+ # @type LoadBalancerId: String
3440
+ # @param ListenerId: 四层监听器ID。可通过接口DescribeL4Listeners查询。
3441
+ # @type ListenerId: String
3442
+ # @param ListenerName: 四层监听器名称。
3443
+ # @type ListenerName: String
3444
+ # @param SessionExpire: 会话保持时间,单位:秒。可选值:900~3600。
3445
+ # @type SessionExpire: Integer
3446
+ # @param HealthSwitch: 是否开启健康检查:1(开启)、0(关闭)。默认值0,表示关闭。
3447
+ # @type HealthSwitch: Integer
3448
+ # @param TimeOut: 健康检查的响应超时时间,可选值:2-60,默认值:2,单位:秒。<br><font color="red">响应超时时间要小于检查间隔时间。</font>
3449
+ # @type TimeOut: Integer
3450
+ # @param IntervalTime: 健康检查间隔,默认值:5,可选值:5-300,单位:秒。
3451
+ # @type IntervalTime: Integer
3452
+ # @param HealthNum: 健康阈值,默认值:3,表示当连续探测三次健康则表示该转发正常,可选值:2-10,单位:次。
3453
+ # @type HealthNum: Integer
3454
+ # @param UnhealthNum: 不健康阈值,默认值:3,表示当连续探测三次不健康则表示该转发不正常,可选值:2-10,单位:次。
3455
+ # @type UnhealthNum: Integer
3456
+ # @param Bandwidth: 监听器最大带宽值,用于计费模式为固定带宽计费。可选值:0-1000,单位:Mbps。
3457
+ # @type Bandwidth: Integer
3458
+ # @param CustomHealthSwitch: 是否开启自定义健康检查:1(开启)、0(关闭)。默认值0,表示关闭。(该字段在健康检查开启的情况下才生效)
3459
+ # @type CustomHealthSwitch: Integer
3460
+ # @param InputType: 自定义健康探测内容类型,可选值:text(文本)、hexadecimal(十六进制)。
3461
+ # @type InputType: String
3462
+ # @param LineSeparatorType: 探测内容类型为文本方式时,针对请求文本中换行替换方式。可选值:1(替换为LF)、2(替换为CR)、3(替换为LF+CR)。
3463
+ # @type LineSeparatorType: Integer
3464
+ # @param HealthRequest: 自定义探测请求内容。
3465
+ # @type HealthRequest: String
3466
+ # @param HealthResponse: 自定义探测返回内容。
3467
+ # @type HealthResponse: String
3468
+ # @param ToaFlag: 是否开启toa。可选值:0(关闭)、1(开启),默认关闭。(该字段在负载均衡为fullnat类型下才生效)
3469
+ # @type ToaFlag: Integer
3470
+ # @param BalanceMode: 四层调度方式。wrr,wlc。
3471
+ # @type BalanceMode: String
3472
+
3473
+ attr_accessor :LoadBalancerId, :ListenerId, :ListenerName, :SessionExpire, :HealthSwitch, :TimeOut, :IntervalTime, :HealthNum, :UnhealthNum, :Bandwidth, :CustomHealthSwitch, :InputType, :LineSeparatorType, :HealthRequest, :HealthResponse, :ToaFlag, :BalanceMode
3474
+
3475
+ def initialize(loadbalancerid=nil, listenerid=nil, listenername=nil, sessionexpire=nil, healthswitch=nil, timeout=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, bandwidth=nil, customhealthswitch=nil, inputtype=nil, lineseparatortype=nil, healthrequest=nil, healthresponse=nil, toaflag=nil, balancemode=nil)
3476
+ @LoadBalancerId = loadbalancerid
3477
+ @ListenerId = listenerid
3478
+ @ListenerName = listenername
3479
+ @SessionExpire = sessionexpire
3480
+ @HealthSwitch = healthswitch
3481
+ @TimeOut = timeout
3482
+ @IntervalTime = intervaltime
3483
+ @HealthNum = healthnum
3484
+ @UnhealthNum = unhealthnum
3485
+ @Bandwidth = bandwidth
3486
+ @CustomHealthSwitch = customhealthswitch
3487
+ @InputType = inputtype
3488
+ @LineSeparatorType = lineseparatortype
3489
+ @HealthRequest = healthrequest
3490
+ @HealthResponse = healthresponse
3491
+ @ToaFlag = toaflag
3492
+ @BalanceMode = balancemode
3493
+ end
3494
+
3495
+ def deserialize(params)
3496
+ @LoadBalancerId = params['LoadBalancerId']
3497
+ @ListenerId = params['ListenerId']
3498
+ @ListenerName = params['ListenerName']
3499
+ @SessionExpire = params['SessionExpire']
3500
+ @HealthSwitch = params['HealthSwitch']
3501
+ @TimeOut = params['TimeOut']
3502
+ @IntervalTime = params['IntervalTime']
3503
+ @HealthNum = params['HealthNum']
3504
+ @UnhealthNum = params['UnhealthNum']
3505
+ @Bandwidth = params['Bandwidth']
3506
+ @CustomHealthSwitch = params['CustomHealthSwitch']
3507
+ @InputType = params['InputType']
3508
+ @LineSeparatorType = params['LineSeparatorType']
3509
+ @HealthRequest = params['HealthRequest']
3510
+ @HealthResponse = params['HealthResponse']
3511
+ @ToaFlag = params['ToaFlag']
3512
+ @BalanceMode = params['BalanceMode']
3513
+ end
3514
+ end
3515
+
3516
+ # ModifyL4Listener返回参数结构体
3517
+ class ModifyL4ListenerResponse < TencentCloud::Common::AbstractModel
3518
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
3519
+ # @type TaskId: String
3520
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3521
+ # @type RequestId: String
3522
+
3523
+ attr_accessor :TaskId, :RequestId
3524
+
3525
+ def initialize(taskid=nil, requestid=nil)
3526
+ @TaskId = taskid
3527
+ @RequestId = requestid
3528
+ end
3529
+
3530
+ def deserialize(params)
3531
+ @TaskId = params['TaskId']
3532
+ @RequestId = params['RequestId']
3533
+ end
3534
+ end
3535
+
3536
+ # ModifyL7BackendPort请求参数结构体
3537
+ class ModifyL7BackendPortRequest < TencentCloud::Common::AbstractModel
3538
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3539
+ # @type LoadBalancerId: String
3540
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
3541
+ # @type ListenerId: String
3542
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
3543
+ # @type DomainId: String
3544
+ # @param LocationId: 转发路径实例ID,可通过接口DescribeL7Rules查询。
3545
+ # @type LocationId: String
3546
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
3547
+ # @type InstanceId: String
3548
+ # @param Port: 已绑定的主机端口。
3549
+ # @type Port: Integer
3550
+ # @param NewPort: 新的主机端口,可选值1~65535。
3551
+ # @type NewPort: Integer
3552
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
3553
+ # @type BindType: Integer
3554
+
3555
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainId, :LocationId, :InstanceId, :Port, :NewPort, :BindType
3556
+
3557
+ def initialize(loadbalancerid=nil, listenerid=nil, domainid=nil, locationid=nil, instanceid=nil, port=nil, newport=nil, bindtype=nil)
3558
+ @LoadBalancerId = loadbalancerid
3559
+ @ListenerId = listenerid
3560
+ @DomainId = domainid
3561
+ @LocationId = locationid
3562
+ @InstanceId = instanceid
3563
+ @Port = port
3564
+ @NewPort = newport
3565
+ @BindType = bindtype
3566
+ end
3567
+
3568
+ def deserialize(params)
3569
+ @LoadBalancerId = params['LoadBalancerId']
3570
+ @ListenerId = params['ListenerId']
3571
+ @DomainId = params['DomainId']
3572
+ @LocationId = params['LocationId']
3573
+ @InstanceId = params['InstanceId']
3574
+ @Port = params['Port']
3575
+ @NewPort = params['NewPort']
3576
+ @BindType = params['BindType']
3577
+ end
3578
+ end
3579
+
3580
+ # ModifyL7BackendPort返回参数结构体
3581
+ class ModifyL7BackendPortResponse < TencentCloud::Common::AbstractModel
3582
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
3583
+ # @type TaskId: String
3584
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3585
+ # @type RequestId: String
3586
+
3587
+ attr_accessor :TaskId, :RequestId
3588
+
3589
+ def initialize(taskid=nil, requestid=nil)
3590
+ @TaskId = taskid
3591
+ @RequestId = requestid
3592
+ end
3593
+
3594
+ def deserialize(params)
3595
+ @TaskId = params['TaskId']
3596
+ @RequestId = params['RequestId']
3597
+ end
3598
+ end
3599
+
3600
+ # ModifyL7BackendWeight请求参数结构体
3601
+ class ModifyL7BackendWeightRequest < TencentCloud::Common::AbstractModel
3602
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3603
+ # @type LoadBalancerId: String
3604
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
3605
+ # @type ListenerId: String
3606
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
3607
+ # @type DomainId: String
3608
+ # @param LocationId: 转发路径实例ID,可通过接口DescribeL7Rules查询。
3609
+ # @type LocationId: String
3610
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
3611
+ # @type InstanceId: String
3612
+ # @param Weight: 权重信息,可选值0~100。
3613
+ # @type Weight: Integer
3614
+ # @param Port: 已绑定的主机端口。
3615
+ # @type Port: Integer
3616
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
3617
+ # @type BindType: Integer
3618
+
3619
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainId, :LocationId, :InstanceId, :Weight, :Port, :BindType
3620
+
3621
+ def initialize(loadbalancerid=nil, listenerid=nil, domainid=nil, locationid=nil, instanceid=nil, weight=nil, port=nil, bindtype=nil)
3622
+ @LoadBalancerId = loadbalancerid
3623
+ @ListenerId = listenerid
3624
+ @DomainId = domainid
3625
+ @LocationId = locationid
3626
+ @InstanceId = instanceid
3627
+ @Weight = weight
3628
+ @Port = port
3629
+ @BindType = bindtype
3630
+ end
3631
+
3632
+ def deserialize(params)
3633
+ @LoadBalancerId = params['LoadBalancerId']
3634
+ @ListenerId = params['ListenerId']
3635
+ @DomainId = params['DomainId']
3636
+ @LocationId = params['LocationId']
3637
+ @InstanceId = params['InstanceId']
3638
+ @Weight = params['Weight']
3639
+ @Port = params['Port']
3640
+ @BindType = params['BindType']
3641
+ end
3642
+ end
3643
+
3644
+ # ModifyL7BackendWeight返回参数结构体
3645
+ class ModifyL7BackendWeightResponse < TencentCloud::Common::AbstractModel
3646
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果
3647
+ # @type TaskId: String
3648
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3649
+ # @type RequestId: String
3650
+
3651
+ attr_accessor :TaskId, :RequestId
3652
+
3653
+ def initialize(taskid=nil, requestid=nil)
3654
+ @TaskId = taskid
3655
+ @RequestId = requestid
3656
+ end
3657
+
3658
+ def deserialize(params)
3659
+ @TaskId = params['TaskId']
3660
+ @RequestId = params['RequestId']
3661
+ end
3662
+ end
3663
+
3664
+ # ModifyL7Listener请求参数结构体
3665
+ class ModifyL7ListenerRequest < TencentCloud::Common::AbstractModel
3666
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3667
+ # @type LoadBalancerId: String
3668
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
3669
+ # @type ListenerId: String
3670
+ # @param ListenerName: 七层监听器名称。
3671
+ # @type ListenerName: String
3672
+ # @param SslMode: 认证方式:0(不认证,用于http),1(单向认证,用于https),2(双向认证,用于https)。
3673
+ # @type SslMode: Integer
3674
+ # @param CertId: 服务端证书ID。
3675
+ # @type CertId: String
3676
+ # @param CertName: 服务端证书名称。
3677
+ # @type CertName: String
3678
+ # @param CertContent: 服务端证书内容。
3679
+ # @type CertContent: String
3680
+ # @param CertKey: 服务端证书密钥。
3681
+ # @type CertKey: String
3682
+ # @param CertCaId: 客户端证书ID。
3683
+ # @type CertCaId: String
3684
+ # @param CertCaName: 客户端证书名称。
3685
+ # @type CertCaName: String
3686
+ # @param CertCaContent: 客户端证书内容。
3687
+ # @type CertCaContent: String
3688
+ # @param Bandwidth: 计费模式为按固定带宽方式时监听器的限速值,可选值:0-1000,单位:Mbps。
3689
+ # @type Bandwidth: Integer
3690
+ # @param ForwardProtocol: 转发协议。当监听器Protocol为https时并且SslMode为1或2时,有意义。可选的值为0:https,1:spdy,2:http2,3:spdy+http2。
3691
+ # @type ForwardProtocol: Integer
3692
+
3693
+ attr_accessor :LoadBalancerId, :ListenerId, :ListenerName, :SslMode, :CertId, :CertName, :CertContent, :CertKey, :CertCaId, :CertCaName, :CertCaContent, :Bandwidth, :ForwardProtocol
3694
+
3695
+ def initialize(loadbalancerid=nil, listenerid=nil, listenername=nil, sslmode=nil, certid=nil, certname=nil, certcontent=nil, certkey=nil, certcaid=nil, certcaname=nil, certcacontent=nil, bandwidth=nil, forwardprotocol=nil)
3696
+ @LoadBalancerId = loadbalancerid
3697
+ @ListenerId = listenerid
3698
+ @ListenerName = listenername
3699
+ @SslMode = sslmode
3700
+ @CertId = certid
3701
+ @CertName = certname
3702
+ @CertContent = certcontent
3703
+ @CertKey = certkey
3704
+ @CertCaId = certcaid
3705
+ @CertCaName = certcaname
3706
+ @CertCaContent = certcacontent
3707
+ @Bandwidth = bandwidth
3708
+ @ForwardProtocol = forwardprotocol
3709
+ end
3710
+
3711
+ def deserialize(params)
3712
+ @LoadBalancerId = params['LoadBalancerId']
3713
+ @ListenerId = params['ListenerId']
3714
+ @ListenerName = params['ListenerName']
3715
+ @SslMode = params['SslMode']
3716
+ @CertId = params['CertId']
3717
+ @CertName = params['CertName']
3718
+ @CertContent = params['CertContent']
3719
+ @CertKey = params['CertKey']
3720
+ @CertCaId = params['CertCaId']
3721
+ @CertCaName = params['CertCaName']
3722
+ @CertCaContent = params['CertCaContent']
3723
+ @Bandwidth = params['Bandwidth']
3724
+ @ForwardProtocol = params['ForwardProtocol']
3725
+ end
3726
+ end
3727
+
3728
+ # ModifyL7Listener返回参数结构体
3729
+ class ModifyL7ListenerResponse < TencentCloud::Common::AbstractModel
3730
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用[DescribeLoadBalancerTaskResult](/document/product/386/9308)接口来查询任务操作结果
3731
+ # @type TaskId: String
3732
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3733
+ # @type RequestId: String
3734
+
3735
+ attr_accessor :TaskId, :RequestId
3736
+
3737
+ def initialize(taskid=nil, requestid=nil)
3738
+ @TaskId = taskid
3739
+ @RequestId = requestid
3740
+ end
3741
+
3742
+ def deserialize(params)
3743
+ @TaskId = params['TaskId']
3744
+ @RequestId = params['RequestId']
3745
+ end
3746
+ end
3747
+
3748
+ # 修改黑石负载均衡七层转发路径时待修改的七层转发规则信息。
3749
+ class ModifyL7LocationRule < TencentCloud::Common::AbstractModel
3750
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
3751
+ # @type DomainId: String
3752
+ # @param LocationId: 转发路径实例ID,可通过接口DescribeL7Rules查询。
3753
+ # @type LocationId: String
3754
+ # @param Url: 转发路径。
3755
+ # @type Url: String
3756
+ # @param SessionExpire: 会话保持时间,单位:秒。可选值:30~3600。默认值0,表示不开启会话保持。
3757
+ # @type SessionExpire: Integer
3758
+ # @param HealthSwitch: 健康检查开关:1(开启)、0(关闭)。默认值0,表示关闭。
3759
+ # @type HealthSwitch: Integer
3760
+ # @param IntervalTime: 健康检查检查间隔时间,默认值:5,可选值:5-300,单位:秒。
3761
+ # @type IntervalTime: Integer
3762
+ # @param HealthNum: 健康检查健康阈值,默认值:3,表示当连续探测三次健康则表示该转发正常,可选值:2-10,单位:次。
3763
+ # @type HealthNum: Integer
3764
+ # @param UnhealthNum: 健康检查不健康阈值,默认值:5,表示当连续探测五次不健康则表示该转发不正常,可选值:2-10,单位:次。
3765
+ # @type UnhealthNum: Integer
3766
+ # @param HttpCodes: 健康检查中认为健康的HTTP返回码的组合。可选值为1~5的集合,1表示HTTP返回码为1xx认为健康。2表示HTTP返回码为2xx认为健康。3表示HTTP返回码为3xx认为健康。4表示HTTP返回码为4xx认为健康。5表示HTTP返回码为5xx认为健康。
3767
+ # @type HttpCodes: Array
3768
+ # @param HttpCheckPath: 健康检查检查路径。
3769
+ # @type HttpCheckPath: String
3770
+ # @param HttpCheckDomain: 健康检查检查域名。如果规则的域名使用通配符或正则表达式,则健康检查检查域名可自定义,否则必须跟健康检查检查域名一样。不填表示不修改。
3771
+ # @type HttpCheckDomain: String
3772
+ # @param BalanceMode: 均衡方式:ip_hash、wrr。默认值wrr。
3773
+ # @type BalanceMode: String
3774
+ # @param Domain: 转发域名。
3775
+ # @type Domain: String
3776
+
3777
+ attr_accessor :DomainId, :LocationId, :Url, :SessionExpire, :HealthSwitch, :IntervalTime, :HealthNum, :UnhealthNum, :HttpCodes, :HttpCheckPath, :HttpCheckDomain, :BalanceMode, :Domain
3778
+
3779
+ def initialize(domainid=nil, locationid=nil, url=nil, sessionexpire=nil, healthswitch=nil, intervaltime=nil, healthnum=nil, unhealthnum=nil, httpcodes=nil, httpcheckpath=nil, httpcheckdomain=nil, balancemode=nil, domain=nil)
3780
+ @DomainId = domainid
3781
+ @LocationId = locationid
3782
+ @Url = url
3783
+ @SessionExpire = sessionexpire
3784
+ @HealthSwitch = healthswitch
3785
+ @IntervalTime = intervaltime
3786
+ @HealthNum = healthnum
3787
+ @UnhealthNum = unhealthnum
3788
+ @HttpCodes = httpcodes
3789
+ @HttpCheckPath = httpcheckpath
3790
+ @HttpCheckDomain = httpcheckdomain
3791
+ @BalanceMode = balancemode
3792
+ @Domain = domain
3793
+ end
3794
+
3795
+ def deserialize(params)
3796
+ @DomainId = params['DomainId']
3797
+ @LocationId = params['LocationId']
3798
+ @Url = params['Url']
3799
+ @SessionExpire = params['SessionExpire']
3800
+ @HealthSwitch = params['HealthSwitch']
3801
+ @IntervalTime = params['IntervalTime']
3802
+ @HealthNum = params['HealthNum']
3803
+ @UnhealthNum = params['UnhealthNum']
3804
+ @HttpCodes = params['HttpCodes']
3805
+ @HttpCheckPath = params['HttpCheckPath']
3806
+ @HttpCheckDomain = params['HttpCheckDomain']
3807
+ @BalanceMode = params['BalanceMode']
3808
+ @Domain = params['Domain']
3809
+ end
3810
+ end
3811
+
3812
+ # ModifyL7Locations请求参数结构体
3813
+ class ModifyL7LocationsRequest < TencentCloud::Common::AbstractModel
3814
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3815
+ # @type LoadBalancerId: String
3816
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
3817
+ # @type ListenerId: String
3818
+ # @param RuleSet: 待更新的七层转发规则信息数组。
3819
+ # @type RuleSet: Array
3820
+
3821
+ attr_accessor :LoadBalancerId, :ListenerId, :RuleSet
3822
+
3823
+ def initialize(loadbalancerid=nil, listenerid=nil, ruleset=nil)
3824
+ @LoadBalancerId = loadbalancerid
3825
+ @ListenerId = listenerid
3826
+ @RuleSet = ruleset
3827
+ end
3828
+
3829
+ def deserialize(params)
3830
+ @LoadBalancerId = params['LoadBalancerId']
3831
+ @ListenerId = params['ListenerId']
3832
+ unless params['RuleSet'].nil?
3833
+ @RuleSet = []
3834
+ params['RuleSet'].each do |i|
3835
+ modifyl7locationrule_tmp = ModifyL7LocationRule.new
3836
+ modifyl7locationrule_tmp.deserialize(i)
3837
+ @RuleSet << modifyl7locationrule_tmp
3838
+ end
3839
+ end
3840
+ end
3841
+ end
3842
+
3843
+ # ModifyL7Locations返回参数结构体
3844
+ class ModifyL7LocationsResponse < TencentCloud::Common::AbstractModel
3845
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
3846
+ # @type TaskId: String
3847
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3848
+ # @type RequestId: String
3849
+
3850
+ attr_accessor :TaskId, :RequestId
3851
+
3852
+ def initialize(taskid=nil, requestid=nil)
3853
+ @TaskId = taskid
3854
+ @RequestId = requestid
3855
+ end
3856
+
3857
+ def deserialize(params)
3858
+ @TaskId = params['TaskId']
3859
+ @RequestId = params['RequestId']
3860
+ end
3861
+ end
3862
+
3863
+ # 修改负载均衡计费方式的监听器信息。
3864
+ class ModifyLoadBalancerChargeModeListener < TencentCloud::Common::AbstractModel
3865
+ # @param ListenerId: 监听器ID。
3866
+ # @type ListenerId: String
3867
+ # @param Protocol: 协议类型。
3868
+ # @type Protocol: String
3869
+ # @param Bandwidth: 带宽。
3870
+ # @type Bandwidth: Integer
3871
+
3872
+ attr_accessor :ListenerId, :Protocol, :Bandwidth
3873
+
3874
+ def initialize(listenerid=nil, protocol=nil, bandwidth=nil)
3875
+ @ListenerId = listenerid
3876
+ @Protocol = protocol
3877
+ @Bandwidth = bandwidth
3878
+ end
3879
+
3880
+ def deserialize(params)
3881
+ @ListenerId = params['ListenerId']
3882
+ @Protocol = params['Protocol']
3883
+ @Bandwidth = params['Bandwidth']
3884
+ end
3885
+ end
3886
+
3887
+ # ModifyLoadBalancerChargeMode请求参数结构体
3888
+ class ModifyLoadBalancerChargeModeRequest < TencentCloud::Common::AbstractModel
3889
+ # @param LoadBalancerId: 负载均衡实例ID。
3890
+ # @type LoadBalancerId: String
3891
+ # @param PayMode: 计费方式。flow或bandwidth。
3892
+ # @type PayMode: String
3893
+ # @param ListenerSet: 监听器信息,当计费方式选为 bandwidth 且此负载均衡实例下存在监听器时需填入此字段,可以自定义每个监听器带宽上限。
3894
+ # @type ListenerSet: Array
3895
+
3896
+ attr_accessor :LoadBalancerId, :PayMode, :ListenerSet
3897
+
3898
+ def initialize(loadbalancerid=nil, paymode=nil, listenerset=nil)
3899
+ @LoadBalancerId = loadbalancerid
3900
+ @PayMode = paymode
3901
+ @ListenerSet = listenerset
3902
+ end
3903
+
3904
+ def deserialize(params)
3905
+ @LoadBalancerId = params['LoadBalancerId']
3906
+ @PayMode = params['PayMode']
3907
+ unless params['ListenerSet'].nil?
3908
+ @ListenerSet = []
3909
+ params['ListenerSet'].each do |i|
3910
+ modifyloadbalancerchargemodelistener_tmp = ModifyLoadBalancerChargeModeListener.new
3911
+ modifyloadbalancerchargemodelistener_tmp.deserialize(i)
3912
+ @ListenerSet << modifyloadbalancerchargemodelistener_tmp
3913
+ end
3914
+ end
3915
+ end
3916
+ end
3917
+
3918
+ # ModifyLoadBalancerChargeMode返回参数结构体
3919
+ class ModifyLoadBalancerChargeModeResponse < TencentCloud::Common::AbstractModel
3920
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3921
+ # @type RequestId: String
3922
+
3923
+ attr_accessor :RequestId
3924
+
3925
+ def initialize(requestid=nil)
3926
+ @RequestId = requestid
3927
+ end
3928
+
3929
+ def deserialize(params)
3930
+ @RequestId = params['RequestId']
3931
+ end
3932
+ end
3933
+
3934
+ # ModifyLoadBalancer请求参数结构体
3935
+ class ModifyLoadBalancerRequest < TencentCloud::Common::AbstractModel
3936
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
3937
+ # @type LoadBalancerId: String
3938
+ # @param LoadBalancerName: 负载均衡器名称,规则:1-20个英文、汉字、数字、连接线“-”或下划线“_”。
3939
+ # @type LoadBalancerName: String
3940
+ # @param DomainPrefix: 域名前缀,负载均衡的域名由用户输入的域名前缀与配置文件中的域名后缀一起组合而成,保证是唯一的域名。规则:1-20个小写英文字母、数字或连接线“-”。内网类型的负载均衡不能配置该字段。
3941
+ # @type DomainPrefix: String
3942
+
3943
+ attr_accessor :LoadBalancerId, :LoadBalancerName, :DomainPrefix
3944
+
3945
+ def initialize(loadbalancerid=nil, loadbalancername=nil, domainprefix=nil)
3946
+ @LoadBalancerId = loadbalancerid
3947
+ @LoadBalancerName = loadbalancername
3948
+ @DomainPrefix = domainprefix
3949
+ end
3950
+
3951
+ def deserialize(params)
3952
+ @LoadBalancerId = params['LoadBalancerId']
3953
+ @LoadBalancerName = params['LoadBalancerName']
3954
+ @DomainPrefix = params['DomainPrefix']
3955
+ end
3956
+ end
3957
+
3958
+ # ModifyLoadBalancer返回参数结构体
3959
+ class ModifyLoadBalancerResponse < TencentCloud::Common::AbstractModel
3960
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
3961
+ # @type TaskId: String
3962
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
3963
+ # @type RequestId: String
3964
+
3965
+ attr_accessor :TaskId, :RequestId
3966
+
3967
+ def initialize(taskid=nil, requestid=nil)
3968
+ @TaskId = taskid
3969
+ @RequestId = requestid
3970
+ end
3971
+
3972
+ def deserialize(params)
3973
+ @TaskId = params['TaskId']
3974
+ @RequestId = params['RequestId']
3975
+ end
3976
+ end
3977
+
3978
+ # ReplaceCert请求参数结构体
3979
+ class ReplaceCertRequest < TencentCloud::Common::AbstractModel
3980
+ # @param OldCertId: 要被替换的证书ID
3981
+ # @type OldCertId: String
3982
+ # @param NewCert: 证书内容
3983
+ # @type NewCert: String
3984
+ # @param NewAlias: 证书名称
3985
+ # @type NewAlias: String
3986
+ # @param NewKey: 私钥内容,证书类型为SVR时不需要传递
3987
+ # @type NewKey: String
3988
+ # @param DeleteOld: 是否删除旧证书,0 表示不删除,1 表示删除
3989
+ # @type DeleteOld: Integer
3990
+
3991
+ attr_accessor :OldCertId, :NewCert, :NewAlias, :NewKey, :DeleteOld
3992
+
3993
+ def initialize(oldcertid=nil, newcert=nil, newalias=nil, newkey=nil, deleteold=nil)
3994
+ @OldCertId = oldcertid
3995
+ @NewCert = newcert
3996
+ @NewAlias = newalias
3997
+ @NewKey = newkey
3998
+ @DeleteOld = deleteold
3999
+ end
4000
+
4001
+ def deserialize(params)
4002
+ @OldCertId = params['OldCertId']
4003
+ @NewCert = params['NewCert']
4004
+ @NewAlias = params['NewAlias']
4005
+ @NewKey = params['NewKey']
4006
+ @DeleteOld = params['DeleteOld']
4007
+ end
4008
+ end
4009
+
4010
+ # ReplaceCert返回参数结构体
4011
+ class ReplaceCertResponse < TencentCloud::Common::AbstractModel
4012
+ # @param NewCertId: 新证书ID。
4013
+ # @type NewCertId: String
4014
+ # @param OldCertId: 旧证书ID。
4015
+ # @type OldCertId: String
4016
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4017
+ # @type RequestId: String
4018
+
4019
+ attr_accessor :NewCertId, :OldCertId, :RequestId
4020
+
4021
+ def initialize(newcertid=nil, oldcertid=nil, requestid=nil)
4022
+ @NewCertId = newcertid
4023
+ @OldCertId = oldcertid
4024
+ @RequestId = requestid
4025
+ end
4026
+
4027
+ def deserialize(params)
4028
+ @NewCertId = params['NewCertId']
4029
+ @OldCertId = params['OldCertId']
4030
+ @RequestId = params['RequestId']
4031
+ end
4032
+ end
4033
+
4034
+ # SetTrafficMirrorAlias请求参数结构体
4035
+ class SetTrafficMirrorAliasRequest < TencentCloud::Common::AbstractModel
4036
+ # @param TrafficMirrorId: 流量镜像实例ID。
4037
+ # @type TrafficMirrorId: String
4038
+ # @param Alias: 流量镜像实例别名。
4039
+ # @type Alias: String
4040
+
4041
+ attr_accessor :TrafficMirrorId, :Alias
4042
+
4043
+ def initialize(trafficmirrorid=nil, _alias=nil)
4044
+ @TrafficMirrorId = trafficmirrorid
4045
+ @Alias = _alias
4046
+ end
4047
+
4048
+ def deserialize(params)
4049
+ @TrafficMirrorId = params['TrafficMirrorId']
4050
+ @Alias = params['Alias']
4051
+ end
4052
+ end
4053
+
4054
+ # SetTrafficMirrorAlias返回参数结构体
4055
+ class SetTrafficMirrorAliasResponse < TencentCloud::Common::AbstractModel
4056
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4057
+ # @type RequestId: String
4058
+
4059
+ attr_accessor :RequestId
4060
+
4061
+ def initialize(requestid=nil)
4062
+ @RequestId = requestid
4063
+ end
4064
+
4065
+ def deserialize(params)
4066
+ @RequestId = params['RequestId']
4067
+ end
4068
+ end
4069
+
4070
+ # SetTrafficMirrorHealthSwitch请求参数结构体
4071
+ class SetTrafficMirrorHealthSwitchRequest < TencentCloud::Common::AbstractModel
4072
+ # @param TrafficMirrorId: 流量镜像实例ID。
4073
+ # @type TrafficMirrorId: String
4074
+ # @param HealthSwitch: 健康检查开关,0:关闭,1:打开
4075
+ # @type HealthSwitch: Integer
4076
+ # @param HealthNum: 健康检查判断健康的次数,最小值2,最大值10。
4077
+ # @type HealthNum: Integer
4078
+ # @param UnhealthNum: 健康检查判断不健康的次数,最小值2,最大值10。
4079
+ # @type UnhealthNum: Integer
4080
+ # @param IntervalTime: 健康检查间隔,单位:秒,最小值5,最大值300。
4081
+ # @type IntervalTime: Integer
4082
+ # @param HttpCheckDomain: 检查的域名配置。
4083
+ # @type HttpCheckDomain: String
4084
+ # @param HttpCheckPath: 检查的路径配置。
4085
+ # @type HttpCheckPath: String
4086
+ # @param HttpCodes: 健康检查中认为健康的HTTP返回码的组合。可选值为1~5的集合,1表示HTTP返回码为1xx认为健康。2表示HTTP返回码为2xx认为健康。3表示HTTP返回码为3xx认为健康。4表示HTTP返回码为4xx认为健康。5表示HTTP返回码为5xx认为健康。
4087
+ # @type HttpCodes: Array
4088
+
4089
+ attr_accessor :TrafficMirrorId, :HealthSwitch, :HealthNum, :UnhealthNum, :IntervalTime, :HttpCheckDomain, :HttpCheckPath, :HttpCodes
4090
+
4091
+ def initialize(trafficmirrorid=nil, healthswitch=nil, healthnum=nil, unhealthnum=nil, intervaltime=nil, httpcheckdomain=nil, httpcheckpath=nil, httpcodes=nil)
4092
+ @TrafficMirrorId = trafficmirrorid
4093
+ @HealthSwitch = healthswitch
4094
+ @HealthNum = healthnum
4095
+ @UnhealthNum = unhealthnum
4096
+ @IntervalTime = intervaltime
4097
+ @HttpCheckDomain = httpcheckdomain
4098
+ @HttpCheckPath = httpcheckpath
4099
+ @HttpCodes = httpcodes
4100
+ end
4101
+
4102
+ def deserialize(params)
4103
+ @TrafficMirrorId = params['TrafficMirrorId']
4104
+ @HealthSwitch = params['HealthSwitch']
4105
+ @HealthNum = params['HealthNum']
4106
+ @UnhealthNum = params['UnhealthNum']
4107
+ @IntervalTime = params['IntervalTime']
4108
+ @HttpCheckDomain = params['HttpCheckDomain']
4109
+ @HttpCheckPath = params['HttpCheckPath']
4110
+ @HttpCodes = params['HttpCodes']
4111
+ end
4112
+ end
4113
+
4114
+ # SetTrafficMirrorHealthSwitch返回参数结构体
4115
+ class SetTrafficMirrorHealthSwitchResponse < TencentCloud::Common::AbstractModel
4116
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
4117
+ # @type TaskId: String
4118
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4119
+ # @type RequestId: String
4120
+
4121
+ attr_accessor :TaskId, :RequestId
4122
+
4123
+ def initialize(taskid=nil, requestid=nil)
4124
+ @TaskId = taskid
4125
+ @RequestId = requestid
4126
+ end
4127
+
4128
+ def deserialize(params)
4129
+ @TaskId = params['TaskId']
4130
+ @RequestId = params['RequestId']
4131
+ end
4132
+ end
4133
+
4134
+ # 获取流量镜像实例的列表信息时返回的流量镜像信息。
4135
+ class TrafficMirror < TencentCloud::Common::AbstractModel
4136
+ # @param TrafficMirrorId: 流量镜像ID。
4137
+ # @type TrafficMirrorId: String
4138
+ # @param Alias: 流量镜像名称。
4139
+ # @type Alias: String
4140
+ # @param VpcId: 流量镜像所在的私有网络ID。
4141
+ # @type VpcId: String
4142
+ # @param LoadBalancerType: 接收机负载均衡方式。wrr,ip_hash,wlc。
4143
+ # @type LoadBalancerType: String
4144
+ # @param HealthSwitch: 是否开始对接收机的健康检查。0:关闭,非0:开启。
4145
+ # @type HealthSwitch: Integer
4146
+ # @param HealthNum: 健康阈值。
4147
+ # @type HealthNum: Integer
4148
+ # @param UnhealthNum: 不健康阈值。
4149
+ # @type UnhealthNum: Integer
4150
+ # @param IntervalTime: 检查间隔。
4151
+ # @type IntervalTime: Integer
4152
+ # @param HttpCheckDomain: 检查域名。
4153
+ # @type HttpCheckDomain: String
4154
+ # @param HttpCheckPath: 检查目录。
4155
+ # @type HttpCheckPath: String
4156
+ # @param HttpCodes: 健康检查返回码。 1:1xx,2:2xx,3:3xx,4:4xx,5:5xx。
4157
+ # @type HttpCodes: Array
4158
+ # @param CreateTime: 创建时间。
4159
+ # @type CreateTime: String
4160
+ # @param VpcCidrBlock: 流量镜像所在私有网络的Cidr。
4161
+ # @type VpcCidrBlock: String
4162
+ # @param VpcName: 流量镜像所在私有网络的名称。
4163
+ # @type VpcName: String
4164
+
4165
+ attr_accessor :TrafficMirrorId, :Alias, :VpcId, :LoadBalancerType, :HealthSwitch, :HealthNum, :UnhealthNum, :IntervalTime, :HttpCheckDomain, :HttpCheckPath, :HttpCodes, :CreateTime, :VpcCidrBlock, :VpcName
4166
+
4167
+ def initialize(trafficmirrorid=nil, _alias=nil, vpcid=nil, loadbalancertype=nil, healthswitch=nil, healthnum=nil, unhealthnum=nil, intervaltime=nil, httpcheckdomain=nil, httpcheckpath=nil, httpcodes=nil, createtime=nil, vpccidrblock=nil, vpcname=nil)
4168
+ @TrafficMirrorId = trafficmirrorid
4169
+ @Alias = _alias
4170
+ @VpcId = vpcid
4171
+ @LoadBalancerType = loadbalancertype
4172
+ @HealthSwitch = healthswitch
4173
+ @HealthNum = healthnum
4174
+ @UnhealthNum = unhealthnum
4175
+ @IntervalTime = intervaltime
4176
+ @HttpCheckDomain = httpcheckdomain
4177
+ @HttpCheckPath = httpcheckpath
4178
+ @HttpCodes = httpcodes
4179
+ @CreateTime = createtime
4180
+ @VpcCidrBlock = vpccidrblock
4181
+ @VpcName = vpcname
4182
+ end
4183
+
4184
+ def deserialize(params)
4185
+ @TrafficMirrorId = params['TrafficMirrorId']
4186
+ @Alias = params['Alias']
4187
+ @VpcId = params['VpcId']
4188
+ @LoadBalancerType = params['LoadBalancerType']
4189
+ @HealthSwitch = params['HealthSwitch']
4190
+ @HealthNum = params['HealthNum']
4191
+ @UnhealthNum = params['UnhealthNum']
4192
+ @IntervalTime = params['IntervalTime']
4193
+ @HttpCheckDomain = params['HttpCheckDomain']
4194
+ @HttpCheckPath = params['HttpCheckPath']
4195
+ @HttpCodes = params['HttpCodes']
4196
+ @CreateTime = params['CreateTime']
4197
+ @VpcCidrBlock = params['VpcCidrBlock']
4198
+ @VpcName = params['VpcName']
4199
+ end
4200
+ end
4201
+
4202
+ # 获取流量镜像的监听器列表信息时返回的与流量镜像绑定的监听器信息。
4203
+ class TrafficMirrorListener < TencentCloud::Common::AbstractModel
4204
+ # @param ListenerId: 监听器ID。
4205
+ # @type ListenerId: String
4206
+ # @param ListenerName: 监听器名称。
4207
+ # @type ListenerName: String
4208
+ # @param Protocol: 七层监听器协议类型,可选值:http,https。
4209
+ # @type Protocol: String
4210
+ # @param LoadBalancerPort: 监听器的监听端口。
4211
+ # @type LoadBalancerPort: Integer
4212
+ # @param Bandwidth: 当前带宽。
4213
+ # @type Bandwidth: Integer
4214
+ # @param MaxBandwidth: 带宽上限。
4215
+ # @type MaxBandwidth: Integer
4216
+ # @param ListenerType: 监听器类型。
4217
+ # @type ListenerType: String
4218
+ # @param SslMode: 认证方式:0(不认证,用于http),1(单向认证,用于https),2(双向认证,用于https)。
4219
+ # @type SslMode: Integer
4220
+ # @param CertId: 服务端证书ID。
4221
+ # @type CertId: String
4222
+ # @param CertCaId: 客户端证书ID。
4223
+ # @type CertCaId: String
4224
+ # @param AddTimestamp: 添加时间。
4225
+ # @type AddTimestamp: String
4226
+ # @param LoadBalancerId: 负载均衡ID。
4227
+ # @type LoadBalancerId: String
4228
+ # @param VpcName: 私有网络名称。
4229
+ # @type VpcName: String
4230
+ # @param VpcCidrBlock: 私有网络Cidr。
4231
+ # @type VpcCidrBlock: String
4232
+ # @param LoadBalancerVips: 负载均衡的VIP。
4233
+ # @type LoadBalancerVips: Array
4234
+ # @param LoadBalancerName: 负载均衡名称。
4235
+ # @type LoadBalancerName: String
4236
+ # @param LoadBalancerVipv6s: 负载均衡的IPV6的VIP。
4237
+ # @type LoadBalancerVipv6s: Array
4238
+ # @param IpProtocolType: 支持的IP协议类型。ipv4或者是ipv6。
4239
+ # @type IpProtocolType: String
4240
+
4241
+ attr_accessor :ListenerId, :ListenerName, :Protocol, :LoadBalancerPort, :Bandwidth, :MaxBandwidth, :ListenerType, :SslMode, :CertId, :CertCaId, :AddTimestamp, :LoadBalancerId, :VpcName, :VpcCidrBlock, :LoadBalancerVips, :LoadBalancerName, :LoadBalancerVipv6s, :IpProtocolType
4242
+
4243
+ def initialize(listenerid=nil, listenername=nil, protocol=nil, loadbalancerport=nil, bandwidth=nil, maxbandwidth=nil, listenertype=nil, sslmode=nil, certid=nil, certcaid=nil, addtimestamp=nil, loadbalancerid=nil, vpcname=nil, vpccidrblock=nil, loadbalancervips=nil, loadbalancername=nil, loadbalancervipv6s=nil, ipprotocoltype=nil)
4244
+ @ListenerId = listenerid
4245
+ @ListenerName = listenername
4246
+ @Protocol = protocol
4247
+ @LoadBalancerPort = loadbalancerport
4248
+ @Bandwidth = bandwidth
4249
+ @MaxBandwidth = maxbandwidth
4250
+ @ListenerType = listenertype
4251
+ @SslMode = sslmode
4252
+ @CertId = certid
4253
+ @CertCaId = certcaid
4254
+ @AddTimestamp = addtimestamp
4255
+ @LoadBalancerId = loadbalancerid
4256
+ @VpcName = vpcname
4257
+ @VpcCidrBlock = vpccidrblock
4258
+ @LoadBalancerVips = loadbalancervips
4259
+ @LoadBalancerName = loadbalancername
4260
+ @LoadBalancerVipv6s = loadbalancervipv6s
4261
+ @IpProtocolType = ipprotocoltype
4262
+ end
4263
+
4264
+ def deserialize(params)
4265
+ @ListenerId = params['ListenerId']
4266
+ @ListenerName = params['ListenerName']
4267
+ @Protocol = params['Protocol']
4268
+ @LoadBalancerPort = params['LoadBalancerPort']
4269
+ @Bandwidth = params['Bandwidth']
4270
+ @MaxBandwidth = params['MaxBandwidth']
4271
+ @ListenerType = params['ListenerType']
4272
+ @SslMode = params['SslMode']
4273
+ @CertId = params['CertId']
4274
+ @CertCaId = params['CertCaId']
4275
+ @AddTimestamp = params['AddTimestamp']
4276
+ @LoadBalancerId = params['LoadBalancerId']
4277
+ @VpcName = params['VpcName']
4278
+ @VpcCidrBlock = params['VpcCidrBlock']
4279
+ @LoadBalancerVips = params['LoadBalancerVips']
4280
+ @LoadBalancerName = params['LoadBalancerName']
4281
+ @LoadBalancerVipv6s = params['LoadBalancerVipv6s']
4282
+ @IpProtocolType = params['IpProtocolType']
4283
+ end
4284
+ end
4285
+
4286
+ # 流量镜像健康检查返回的接收机的端口及状态信息。
4287
+ class TrafficMirrorPortStatus < TencentCloud::Common::AbstractModel
4288
+ # @param Port: 接收机端口。
4289
+ # @type Port: Integer
4290
+ # @param Status: 状态。
4291
+ # @type Status: String
4292
+
4293
+ attr_accessor :Port, :Status
4294
+
4295
+ def initialize(port=nil, status=nil)
4296
+ @Port = port
4297
+ @Status = status
4298
+ end
4299
+
4300
+ def deserialize(params)
4301
+ @Port = params['Port']
4302
+ @Status = params['Status']
4303
+ end
4304
+ end
4305
+
4306
+ # 获取与流量镜像绑定的接收机信息时返回的接收机信息。
4307
+ class TrafficMirrorReceiver < TencentCloud::Common::AbstractModel
4308
+ # @param InstanceId: 接收机实例ID。
4309
+ # @type InstanceId: String
4310
+ # @param Port: 接收机接收端口。
4311
+ # @type Port: Integer
4312
+ # @param Weight: 接收机权重。
4313
+ # @type Weight: Integer
4314
+ # @param TrafficMirrorId: 流量镜像ID。
4315
+ # @type TrafficMirrorId: String
4316
+ # @param Alias: 接收机别名。
4317
+ # @type Alias: String
4318
+ # @param LanIp: 接收机内网IP地址。
4319
+ # @type LanIp: String
4320
+ # @param SubnetId: 接收机所在的子网的ID。
4321
+ # @type SubnetId: String
4322
+ # @param SubnetName: 接收机所在的子网的名称。
4323
+ # @type SubnetName: String
4324
+ # @param SubnetCidrBlock: 接收机所在的子网的Cidr。
4325
+ # @type SubnetCidrBlock: String
4326
+ # @param VpcId: 接收机所在的私有网络的ID。
4327
+ # @type VpcId: String
4328
+ # @param VpcName: 接收机所在的私有网络的名称。
4329
+ # @type VpcName: String
4330
+ # @param VpcCidrBlock: 接收机所在的私有网络的Cidr。
4331
+ # @type VpcCidrBlock: String
4332
+ # @param HealthStatus: 接收机的健康状态。
4333
+ # @type HealthStatus: String
4334
+ # @param Operates: 接收机的可以执行的操作集合。
4335
+ # @type Operates: Array
4336
+
4337
+ attr_accessor :InstanceId, :Port, :Weight, :TrafficMirrorId, :Alias, :LanIp, :SubnetId, :SubnetName, :SubnetCidrBlock, :VpcId, :VpcName, :VpcCidrBlock, :HealthStatus, :Operates
4338
+
4339
+ def initialize(instanceid=nil, port=nil, weight=nil, trafficmirrorid=nil, _alias=nil, lanip=nil, subnetid=nil, subnetname=nil, subnetcidrblock=nil, vpcid=nil, vpcname=nil, vpccidrblock=nil, healthstatus=nil, operates=nil)
4340
+ @InstanceId = instanceid
4341
+ @Port = port
4342
+ @Weight = weight
4343
+ @TrafficMirrorId = trafficmirrorid
4344
+ @Alias = _alias
4345
+ @LanIp = lanip
4346
+ @SubnetId = subnetid
4347
+ @SubnetName = subnetname
4348
+ @SubnetCidrBlock = subnetcidrblock
4349
+ @VpcId = vpcid
4350
+ @VpcName = vpcname
4351
+ @VpcCidrBlock = vpccidrblock
4352
+ @HealthStatus = healthstatus
4353
+ @Operates = operates
4354
+ end
4355
+
4356
+ def deserialize(params)
4357
+ @InstanceId = params['InstanceId']
4358
+ @Port = params['Port']
4359
+ @Weight = params['Weight']
4360
+ @TrafficMirrorId = params['TrafficMirrorId']
4361
+ @Alias = params['Alias']
4362
+ @LanIp = params['LanIp']
4363
+ @SubnetId = params['SubnetId']
4364
+ @SubnetName = params['SubnetName']
4365
+ @SubnetCidrBlock = params['SubnetCidrBlock']
4366
+ @VpcId = params['VpcId']
4367
+ @VpcName = params['VpcName']
4368
+ @VpcCidrBlock = params['VpcCidrBlock']
4369
+ @HealthStatus = params['HealthStatus']
4370
+ @Operates = params['Operates']
4371
+ end
4372
+ end
4373
+
4374
+ # 流量镜像健康检查返回的接收机状态信息。
4375
+ class TrafficMirrorReciversStatus < TencentCloud::Common::AbstractModel
4376
+ # @param LanIp: 内网IP。
4377
+ # @type LanIp: String
4378
+ # @param ReceiversPortStatusSet: 端口及对应的状态。
4379
+ # @type ReceiversPortStatusSet: Array
4380
+
4381
+ attr_accessor :LanIp, :ReceiversPortStatusSet
4382
+
4383
+ def initialize(lanip=nil, receiversportstatusset=nil)
4384
+ @LanIp = lanip
4385
+ @ReceiversPortStatusSet = receiversportstatusset
4386
+ end
4387
+
4388
+ def deserialize(params)
4389
+ @LanIp = params['LanIp']
4390
+ unless params['ReceiversPortStatusSet'].nil?
4391
+ @ReceiversPortStatusSet = []
4392
+ params['ReceiversPortStatusSet'].each do |i|
4393
+ trafficmirrorportstatus_tmp = TrafficMirrorPortStatus.new
4394
+ trafficmirrorportstatus_tmp.deserialize(i)
4395
+ @ReceiversPortStatusSet << trafficmirrorportstatus_tmp
4396
+ end
4397
+ end
4398
+ end
4399
+ end
4400
+
4401
+ # 待与四层监听器解绑的物理机主机、虚拟机或半托管主机信息。
4402
+ class UnbindL4Backend < TencentCloud::Common::AbstractModel
4403
+ # @param Port: 待解绑的主机端口,可选值1~65535。
4404
+ # @type Port: Integer
4405
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
4406
+ # @type InstanceId: String
4407
+
4408
+ attr_accessor :Port, :InstanceId
4409
+
4410
+ def initialize(port=nil, instanceid=nil)
4411
+ @Port = port
4412
+ @InstanceId = instanceid
4413
+ end
4414
+
4415
+ def deserialize(params)
4416
+ @Port = params['Port']
4417
+ @InstanceId = params['InstanceId']
4418
+ end
4419
+ end
4420
+
4421
+ # UnbindL4Backends请求参数结构体
4422
+ class UnbindL4BackendsRequest < TencentCloud::Common::AbstractModel
4423
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
4424
+ # @type LoadBalancerId: String
4425
+ # @param ListenerId: 负载均衡四层监听器ID,可通过接口DescribeL4Listeners查询。
4426
+ # @type ListenerId: String
4427
+ # @param BackendSet: 待解绑的主机信息。可以绑定多个主机端口。目前一个四层监听器下面最多允许绑定255个主机端口。
4428
+ # @type BackendSet: Array
4429
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
4430
+ # @type BindType: Integer
4431
+
4432
+ attr_accessor :LoadBalancerId, :ListenerId, :BackendSet, :BindType
4433
+
4434
+ def initialize(loadbalancerid=nil, listenerid=nil, backendset=nil, bindtype=nil)
4435
+ @LoadBalancerId = loadbalancerid
4436
+ @ListenerId = listenerid
4437
+ @BackendSet = backendset
4438
+ @BindType = bindtype
4439
+ end
4440
+
4441
+ def deserialize(params)
4442
+ @LoadBalancerId = params['LoadBalancerId']
4443
+ @ListenerId = params['ListenerId']
4444
+ unless params['BackendSet'].nil?
4445
+ @BackendSet = []
4446
+ params['BackendSet'].each do |i|
4447
+ unbindl4backend_tmp = UnbindL4Backend.new
4448
+ unbindl4backend_tmp.deserialize(i)
4449
+ @BackendSet << unbindl4backend_tmp
4450
+ end
4451
+ end
4452
+ @BindType = params['BindType']
4453
+ end
4454
+ end
4455
+
4456
+ # UnbindL4Backends返回参数结构体
4457
+ class UnbindL4BackendsResponse < TencentCloud::Common::AbstractModel
4458
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
4459
+ # @type TaskId: String
4460
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4461
+ # @type RequestId: String
4462
+
4463
+ attr_accessor :TaskId, :RequestId
4464
+
4465
+ def initialize(taskid=nil, requestid=nil)
4466
+ @TaskId = taskid
4467
+ @RequestId = requestid
4468
+ end
4469
+
4470
+ def deserialize(params)
4471
+ @TaskId = params['TaskId']
4472
+ @RequestId = params['RequestId']
4473
+ end
4474
+ end
4475
+
4476
+ # 待与七层监听器转发规则解绑的物理机主机、虚拟机或半托管主机信息。
4477
+ class UnbindL7Backend < TencentCloud::Common::AbstractModel
4478
+ # @param Port: 待解绑的主机端口,可选值1~65535。
4479
+ # @type Port: Integer
4480
+ # @param InstanceId: 黑石物理机主机ID、虚拟机IP或者是半托管主机ID。
4481
+ # @type InstanceId: String
4482
+
4483
+ attr_accessor :Port, :InstanceId
4484
+
4485
+ def initialize(port=nil, instanceid=nil)
4486
+ @Port = port
4487
+ @InstanceId = instanceid
4488
+ end
4489
+
4490
+ def deserialize(params)
4491
+ @Port = params['Port']
4492
+ @InstanceId = params['InstanceId']
4493
+ end
4494
+ end
4495
+
4496
+ # UnbindL7Backends请求参数结构体
4497
+ class UnbindL7BackendsRequest < TencentCloud::Common::AbstractModel
4498
+ # @param LoadBalancerId: 负载均衡实例ID,可通过接口DescribeLoadBalancers查询。
4499
+ # @type LoadBalancerId: String
4500
+ # @param ListenerId: 七层监听器实例ID,可通过接口DescribeL7Listeners查询。
4501
+ # @type ListenerId: String
4502
+ # @param DomainId: 转发域名实例ID,可通过接口DescribeL7Rules查询。
4503
+ # @type DomainId: String
4504
+ # @param LocationId: 转发路径实例ID,可通过接口DescribeL7Rules查询。
4505
+ # @type LocationId: String
4506
+ # @param BackendSet: 待绑定的主机信息。
4507
+ # @type BackendSet: Array
4508
+ # @param BindType: 绑定类型。0:物理机 1:虚拟机 2:半托管机器
4509
+ # @type BindType: Integer
4510
+
4511
+ attr_accessor :LoadBalancerId, :ListenerId, :DomainId, :LocationId, :BackendSet, :BindType
4512
+
4513
+ def initialize(loadbalancerid=nil, listenerid=nil, domainid=nil, locationid=nil, backendset=nil, bindtype=nil)
4514
+ @LoadBalancerId = loadbalancerid
4515
+ @ListenerId = listenerid
4516
+ @DomainId = domainid
4517
+ @LocationId = locationid
4518
+ @BackendSet = backendset
4519
+ @BindType = bindtype
4520
+ end
4521
+
4522
+ def deserialize(params)
4523
+ @LoadBalancerId = params['LoadBalancerId']
4524
+ @ListenerId = params['ListenerId']
4525
+ @DomainId = params['DomainId']
4526
+ @LocationId = params['LocationId']
4527
+ unless params['BackendSet'].nil?
4528
+ @BackendSet = []
4529
+ params['BackendSet'].each do |i|
4530
+ unbindl7backend_tmp = UnbindL7Backend.new
4531
+ unbindl7backend_tmp.deserialize(i)
4532
+ @BackendSet << unbindl7backend_tmp
4533
+ end
4534
+ end
4535
+ @BindType = params['BindType']
4536
+ end
4537
+ end
4538
+
4539
+ # UnbindL7Backends返回参数结构体
4540
+ class UnbindL7BackendsResponse < TencentCloud::Common::AbstractModel
4541
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
4542
+ # @type TaskId: String
4543
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4544
+ # @type RequestId: String
4545
+
4546
+ attr_accessor :TaskId, :RequestId
4547
+
4548
+ def initialize(taskid=nil, requestid=nil)
4549
+ @TaskId = taskid
4550
+ @RequestId = requestid
4551
+ end
4552
+
4553
+ def deserialize(params)
4554
+ @TaskId = params['TaskId']
4555
+ @RequestId = params['RequestId']
4556
+ end
4557
+ end
4558
+
4559
+ # UnbindTrafficMirrorListeners请求参数结构体
4560
+ class UnbindTrafficMirrorListenersRequest < TencentCloud::Common::AbstractModel
4561
+ # @param TrafficMirrorId: 流量镜像实例ID。
4562
+ # @type TrafficMirrorId: String
4563
+ # @param ListenerIds: 七层监听器实例ID数组,可通过接口DescribeL7Listeners查询。
4564
+ # @type ListenerIds: Array
4565
+
4566
+ attr_accessor :TrafficMirrorId, :ListenerIds
4567
+
4568
+ def initialize(trafficmirrorid=nil, listenerids=nil)
4569
+ @TrafficMirrorId = trafficmirrorid
4570
+ @ListenerIds = listenerids
4571
+ end
4572
+
4573
+ def deserialize(params)
4574
+ @TrafficMirrorId = params['TrafficMirrorId']
4575
+ @ListenerIds = params['ListenerIds']
4576
+ end
4577
+ end
4578
+
4579
+ # UnbindTrafficMirrorListeners返回参数结构体
4580
+ class UnbindTrafficMirrorListenersResponse < TencentCloud::Common::AbstractModel
4581
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
4582
+ # @type TaskId: String
4583
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4584
+ # @type RequestId: String
4585
+
4586
+ attr_accessor :TaskId, :RequestId
4587
+
4588
+ def initialize(taskid=nil, requestid=nil)
4589
+ @TaskId = taskid
4590
+ @RequestId = requestid
4591
+ end
4592
+
4593
+ def deserialize(params)
4594
+ @TaskId = params['TaskId']
4595
+ @RequestId = params['RequestId']
4596
+ end
4597
+ end
4598
+
4599
+ # 待与流量镜像解绑的接收机信息。
4600
+ class UnbindTrafficMirrorReceiver < TencentCloud::Common::AbstractModel
4601
+ # @param Port: 待解绑的主机端口,可选值1~65535。
4602
+ # @type Port: Integer
4603
+ # @param InstanceId: 待解绑的主机实例ID。
4604
+ # @type InstanceId: String
4605
+
4606
+ attr_accessor :Port, :InstanceId
4607
+
4608
+ def initialize(port=nil, instanceid=nil)
4609
+ @Port = port
4610
+ @InstanceId = instanceid
4611
+ end
4612
+
4613
+ def deserialize(params)
4614
+ @Port = params['Port']
4615
+ @InstanceId = params['InstanceId']
4616
+ end
4617
+ end
4618
+
4619
+ # UnbindTrafficMirrorReceivers请求参数结构体
4620
+ class UnbindTrafficMirrorReceiversRequest < TencentCloud::Common::AbstractModel
4621
+ # @param TrafficMirrorId: 流量镜像实例ID。
4622
+ # @type TrafficMirrorId: String
4623
+ # @param ReceiverSet: 待绑定的主机实例ID和端口数组。
4624
+ # @type ReceiverSet: Array
4625
+
4626
+ attr_accessor :TrafficMirrorId, :ReceiverSet
4627
+
4628
+ def initialize(trafficmirrorid=nil, receiverset=nil)
4629
+ @TrafficMirrorId = trafficmirrorid
4630
+ @ReceiverSet = receiverset
4631
+ end
4632
+
4633
+ def deserialize(params)
4634
+ @TrafficMirrorId = params['TrafficMirrorId']
4635
+ unless params['ReceiverSet'].nil?
4636
+ @ReceiverSet = []
4637
+ params['ReceiverSet'].each do |i|
4638
+ unbindtrafficmirrorreceiver_tmp = UnbindTrafficMirrorReceiver.new
4639
+ unbindtrafficmirrorreceiver_tmp.deserialize(i)
4640
+ @ReceiverSet << unbindtrafficmirrorreceiver_tmp
4641
+ end
4642
+ end
4643
+ end
4644
+ end
4645
+
4646
+ # UnbindTrafficMirrorReceivers返回参数结构体
4647
+ class UnbindTrafficMirrorReceiversResponse < TencentCloud::Common::AbstractModel
4648
+ # @param TaskId: 任务ID。该接口为异步任务,可根据本参数调用DescribeLoadBalancerTaskResult接口来查询任务操作结果。
4649
+ # @type TaskId: String
4650
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4651
+ # @type RequestId: String
4652
+
4653
+ attr_accessor :TaskId, :RequestId
4654
+
4655
+ def initialize(taskid=nil, requestid=nil)
4656
+ @TaskId = taskid
4657
+ @RequestId = requestid
4658
+ end
4659
+
4660
+ def deserialize(params)
4661
+ @TaskId = params['TaskId']
4662
+ @RequestId = params['RequestId']
4663
+ end
4664
+ end
4665
+
4666
+ # UploadCert请求参数结构体
4667
+ class UploadCertRequest < TencentCloud::Common::AbstractModel
4668
+ # @param CertType: 证书类型,可选值:CA,SVR。
4669
+ # @type CertType: String
4670
+ # @param Cert: 证书内容。
4671
+ # @type Cert: String
4672
+ # @param Alias: 证书别名。
4673
+ # @type Alias: String
4674
+ # @param Key: 私钥内容,证书类型为SVR时不需要传递。
4675
+ # @type Key: String
4676
+
4677
+ attr_accessor :CertType, :Cert, :Alias, :Key
4678
+
4679
+ def initialize(certtype=nil, cert=nil, _alias=nil, key=nil)
4680
+ @CertType = certtype
4681
+ @Cert = cert
4682
+ @Alias = _alias
4683
+ @Key = key
4684
+ end
4685
+
4686
+ def deserialize(params)
4687
+ @CertType = params['CertType']
4688
+ @Cert = params['Cert']
4689
+ @Alias = params['Alias']
4690
+ @Key = params['Key']
4691
+ end
4692
+ end
4693
+
4694
+ # UploadCert返回参数结构体
4695
+ class UploadCertResponse < TencentCloud::Common::AbstractModel
4696
+ # @param CertId: 新建的证书ID。
4697
+ # @type CertId: String
4698
+ # @param RequestId: 唯一请求 ID,每次请求都会返回。定位问题时需要提供该次请求的 RequestId。
4699
+ # @type RequestId: String
4700
+
4701
+ attr_accessor :CertId, :RequestId
4702
+
4703
+ def initialize(certid=nil, requestid=nil)
4704
+ @CertId = certid
4705
+ @RequestId = requestid
4706
+ end
4707
+
4708
+ def deserialize(params)
4709
+ @CertId = params['CertId']
4710
+ @RequestId = params['RequestId']
4711
+ end
4712
+ end
4713
+
4714
+ end
4715
+ end
4716
+ end
4717
+