This repository has been archived by the owner on Feb 27, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 34
/
contour_types.go
612 lines (547 loc) · 23.3 KB
/
contour_types.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
// Copyright Project Contour Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package v1alpha1
import (
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
// NOTE: json tags are required. Any new fields you add must have json tags for the fields to be serialized.
const (
// OwningContourNameLabel is the owner reference label used for a Contour
// created by the operator. The value should be the name of the contour.
OwningContourNameLabel = "contour.operator.projectcontour.io/owning-contour-name"
// OwningContourNsLabel is the owner reference label used for a Contour
// created by the operator. The value should be the namespace of the contour.
OwningContourNsLabel = "contour.operator.projectcontour.io/owning-contour-namespace"
// ContourFinalizer is the name of the finalizer used for a Contour.
ContourFinalizer = "contour.operator.projectcontour.io/finalizer"
)
// +kubebuilder:object:root=true
// Contour is the Schema for the contours API.
// +kubebuilder:subresource:status
// +kubebuilder:printcolumn:name="Ready",type=string,JSONPath=`.status.conditions[?(@.type=="Available")].status`
// +kubebuilder:printcolumn:name="Reason",type=string,JSONPath=`.status.conditions[?(@.type=="Available")].reason`
type Contour struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
// Spec defines the desired state of Contour.
Spec ContourSpec `json:"spec,omitempty"`
// Status defines the observed state of Contour.
Status ContourStatus `json:"status,omitempty"`
}
// +kubebuilder:object:root=true
// ContourList contains a list of Contour.
type ContourList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []Contour `json:"items"`
}
// ContourSpec defines the desired state of Contour.
type ContourSpec struct {
// Replicas is the desired number of Contour replicas. If unset,
// defaults to 2.
//
// +kubebuilder:default=2
// +kubebuilder:validation:Minimum=0
Replicas int32 `json:"replicas,omitempty"`
// Namespace defines the schema of a Contour namespace. See each field for
// additional details.
//
// +kubebuilder:default={name: "projectcontour", removeOnDeletion: false}
Namespace NamespaceSpec `json:"namespace,omitempty"`
// NetworkPublishing defines the schema for publishing Contour to a network.
//
// See each field for additional details.
//
// +kubebuilder:default={envoy: {type: LoadBalancerService, containerPorts: {{name: http, portNumber: 8080}, {name: https, portNumber: 8443}}}}
NetworkPublishing NetworkPublishing `json:"networkPublishing,omitempty"`
// GatewayClassRef is a reference to a GatewayClass name used for
// managing a Contour.
// DEPRECATED: The contour operator no longer reconciles GatewayClasses.
//
// +kubebuilder:validation:MaxLength=253
// +optional
GatewayClassRef *string `json:"gatewayClassRef,omitempty"`
// GatewayControllerName is used to determine which GatewayClass
// Contour reconciles. The string takes the form of
// "projectcontour.io/<namespace>/contour". If unset, Contour will not
// reconcile Gateway API resources.
//
// +kubebuilder:validation:MaxLength=253
// +optional
GatewayControllerName *string `json:"gatewayControllerName,omitempty"`
// IngressClassName is the name of the IngressClass used by Contour. If unset,
// Contour will process all ingress objects without an ingress class annotation
// or ingress objects with an annotation matching ingress-class=contour. When
// specified, Contour will only process ingress objects that match the provided
// class.
//
// For additional IngressClass details, refer to:
// https://projectcontour.io/docs/main/config/annotations/#ingress-class
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=253
// +optional
IngressClassName *string `json:"ingressClassName,omitempty"`
// NodePlacement enables scheduling of Contour and Envoy pods onto specific nodes.
//
// See each field for additional details.
//
// +optional
NodePlacement *NodePlacement `json:"nodePlacement,omitempty"`
// EnableExternalNameService enables ExternalName Services.
// ExternalName Services are disabled by default due to CVE-2021-XXXXX
// You can re-enable them by setting this setting to "true".
// This is not recommended without understanding the security implications.
// Please see the advisory at https://github.com/projectcontour/contour/security/advisories/GHSA-5ph6-qq5x-7jwc for the details.
//
// +optional
EnableExternalNameService *bool `json:"enableExternalNameService,omitempty"`
}
// NodePlacement describes node scheduling configuration of Contour and Envoy pods.
type NodePlacement struct {
// Contour describes node scheduling configuration of Contour pods.
//
// +optional
Contour *ContourNodePlacement `json:"contour,omitempty"`
// Envoy describes node scheduling configuration of Envoy pods.
//
// +optional
Envoy *EnvoyNodePlacement `json:"envoy,omitempty"`
}
// ContourNodePlacement describes node scheduling configuration for Contour pods.
// If nodeSelector and tolerations are specified, the scheduler will use both to
// determine where to place the Contour pod(s).
type ContourNodePlacement struct {
// NodeSelector is the simplest recommended form of node selection constraint
// and specifies a map of key-value pairs. For the Contour pod to be eligible
// to run on a node, the node must have each of the indicated key-value pairs
// as labels (it can have additional labels as well).
//
// If unset, the Contour pod(s) will be scheduled to any available node.
//
// +optional
NodeSelector map[string]string `json:"nodeSelector,omitempty"`
// Tolerations work with taints to ensure that Envoy pods are not scheduled
// onto inappropriate nodes. One or more taints are applied to a node; this
// marks that the node should not accept any pods that do not tolerate the
// taints.
//
// The default is an empty list.
//
// See https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
// for additional details.
//
// +optional
Tolerations []corev1.Toleration `json:"tolerations,omitempty"`
}
// EnvoyNodePlacement describes node scheduling configuration for Envoy pods.
// If nodeSelector and tolerations are specified, the scheduler will use both
// to determine where to place the Envoy pod(s).
type EnvoyNodePlacement struct {
// NodeSelector is the simplest recommended form of node selection constraint
// and specifies a map of key-value pairs. For the Envoy pod to be eligible to
// run on a node, the node must have each of the indicated key-value pairs as
// labels (it can have additional labels as well).
//
// If unset, the Envoy pod(s) will be scheduled to any available node.
//
// +optional
NodeSelector map[string]string `json:"nodeSelector,omitempty"`
// Tolerations work with taints to ensure that Envoy pods are not scheduled
// onto inappropriate nodes. One or more taints are applied to a node; this
// marks that the node should not accept any pods that do not tolerate the taints.
//
// The default is an empty list.
//
// See https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/
// for additional details.
//
// +optional
Tolerations []corev1.Toleration `json:"tolerations,omitempty"`
}
// NamespaceSpec defines the schema of a Contour namespace.
type NamespaceSpec struct {
// Name is the name of the namespace to run Contour and dependent
// resources. If unset, defaults to "projectcontour".
//
// +kubebuilder:default=projectcontour
Name string `json:"name,omitempty"`
// RemoveOnDeletion will remove the namespace when the Contour is
// deleted. If set to True, deletion will not occur if any of the
// following conditions exist:
//
// 1. The Contour namespace is "default", "kube-system" or the
// contour-operator's namespace.
//
// 2. Another Contour exists in the namespace.
//
// 3. The namespace does not contain the Contour owning label.
//
// +kubebuilder:default=false
RemoveOnDeletion bool `json:"removeOnDeletion,omitempty"`
}
// NetworkPublishing defines the schema for publishing Contour to a network.
type NetworkPublishing struct {
// Envoy provides the schema for publishing the network endpoints of Envoy.
//
// If unset, defaults to:
// type: LoadBalancerService
// containerPorts:
// - name: http
// portNumber: 8080
// - name: https
// portNumber: 8443
//
// +kubebuilder:default={type: LoadBalancerService, loadBalancer: {scope: External, providerParameters: {type: AWS}}, containerPorts: {{name: http, portNumber: 8080}, {name: https, portNumber: 8443}}}
Envoy EnvoyNetworkPublishing `json:"envoy,omitempty"`
}
// EnvoyNetworkPublishing defines the schema to publish Envoy to a network.
// +union
type EnvoyNetworkPublishing struct {
// Type is the type of publishing strategy to use. Valid values are:
//
// * LoadBalancerService
//
// In this configuration, network endpoints for Envoy use container networking.
// A Kubernetes LoadBalancer Service is created to publish Envoy network
// endpoints. The Service uses port 80 to publish Envoy's HTTP network endpoint
// and port 443 to publish Envoy's HTTPS network endpoint.
//
// See: https://kubernetes.io/docs/concepts/services-networking/service/#loadbalancer
//
// * NodePortService
//
// Publishes Envoy network endpoints using a Kubernetes NodePort Service.
//
// In this configuration, Envoy network endpoints use container networking. A Kubernetes
// NodePort Service is created to publish the network endpoints.
//
// See: https://kubernetes.io/docs/concepts/services-networking/service/#nodeport
//
// * ClusterIPService
//
// Publishes Envoy network endpoints using a Kubernetes ClusterIP Service.
//
// In this configuration, Envoy network endpoints use container networking. A Kubernetes
// ClusterIP Service is created to publish the network endpoints.
//
// See: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
//
// +unionDiscriminator
// +kubebuilder:default=LoadBalancerService
Type NetworkPublishingType `json:"type,omitempty"`
// LoadBalancer holds parameters for the load balancer. Present only if type is
// LoadBalancerService.
//
// If unspecified, defaults to an external Classic AWS ELB.
//
// +kubebuilder:default={scope: External, providerParameters: {type: AWS}}
LoadBalancer LoadBalancerStrategy `json:"loadBalancer,omitempty"`
// NodePorts is a list of network ports to expose on each node's IP at a static
// port number using a NodePort Service. Present only if type is NodePortService.
// A ClusterIP Service, which the NodePort Service routes to, is automatically
// created. You'll be able to contact the NodePort Service, from outside the
// cluster, by requesting <NodeIP>:<NodePort>.
//
// If type is NodePortService and nodePorts is unspecified, two nodeports will be
// created, one named "http" and the other named "https", with port numbers auto
// assigned by Kubernetes API server. For additional information on the NodePort
// Service, see:
//
// https://kubernetes.io/docs/concepts/services-networking/service/#nodeport
//
// Names and port numbers must be unique in the list. Two ports must be specified,
// one named "http" for Envoy's insecure service and one named "https" for Envoy's
// secure service.
//
// +kubebuilder:validation:MinItems=2
// +kubebuilder:validation:MaxItems=2
// +optional
NodePorts []NodePort `json:"nodePorts,omitempty"`
// ContainerPorts is a list of container ports to expose from the Envoy container(s).
// Exposing a port here gives the system additional information about the network
// connections the Envoy container uses, but is primarily informational. Not specifying
// a port here DOES NOT prevent that port from being exposed by Envoy. Any port which is
// listening on the default "0.0.0.0" address inside the Envoy container will be accessible
// from the network. Names and port numbers must be unique in the list container ports. Two
// ports must be specified, one named "http" for Envoy's insecure service and one named
// "https" for Envoy's secure service.
//
// TODO [danehans]: Update minItems to 1, requiring only https when the following issue
// is fixed: https://github.com/projectcontour/contour/issues/2577.
//
// TODO [danehans]: Increase maxItems when https://github.com/projectcontour/contour/pull/3263
// is implemented.
//
// +kubebuilder:validation:MinItems=2
// +kubebuilder:validation:MaxItems=2
// +kubebuilder:default={{name: http, portNumber: 8080}, {name: https, portNumber: 8443}}
ContainerPorts []ContainerPort `json:"containerPorts,omitempty"`
}
// NetworkPublishingType is a way to publish network endpoints.
// +kubebuilder:validation:Enum=LoadBalancerService;NodePortService;ClusterIPService
type NetworkPublishingType string
const (
// LoadBalancerServicePublishingType publishes a network endpoint using a Kubernetes
// LoadBalancer Service.
LoadBalancerServicePublishingType NetworkPublishingType = "LoadBalancerService"
// NodePortServicePublishingType publishes a network endpoint using a Kubernetes
// NodePort Service.
NodePortServicePublishingType NetworkPublishingType = "NodePortService"
// ClusterIPServicePublishingType publishes a network endpoint using a Kubernetes
// ClusterIP Service.
ClusterIPServicePublishingType NetworkPublishingType = "ClusterIPService"
)
// LoadBalancerStrategy holds parameters for a load balancer.
type LoadBalancerStrategy struct {
// Scope indicates the scope at which the load balancer is exposed.
// Possible values are "External" and "Internal".
//
// +kubebuilder:default=External
Scope LoadBalancerScope `json:"scope,omitempty"`
// ProviderParameters contains load balancer information specific to
// the underlying infrastructure provider.
//
// +kubebuilder:default={type: "AWS"}
ProviderParameters ProviderLoadBalancerParameters `json:"providerParameters,omitempty"`
}
// LoadBalancerScope is the scope at which a load balancer is exposed.
// +kubebuilder:validation:Enum=Internal;External
type LoadBalancerScope string
var (
// InternalLoadBalancer is a load balancer that is exposed only on the
// cluster's private network.
InternalLoadBalancer LoadBalancerScope = "Internal"
// ExternalLoadBalancer is a load balancer that is exposed on the
// cluster's public network (which is typically on the Internet).
ExternalLoadBalancer LoadBalancerScope = "External"
)
// ProviderLoadBalancerParameters holds desired load balancer information
// specific to the underlying infrastructure provider.
//
// +union
type ProviderLoadBalancerParameters struct {
// Type is the underlying infrastructure provider for the load balancer.
// Allowed values are "AWS", "Azure", and "GCP".
//
// +unionDiscriminator
// +kubebuilder:default=AWS
Type LoadBalancerProviderType `json:"type,omitempty"`
// AWS provides configuration settings that are specific to AWS
// load balancers.
//
// If empty, defaults will be applied. See specific aws fields for
// details about their defaults.
//
// +optional
AWS *AWSLoadBalancerParameters `json:"aws,omitempty"`
// Azure provides configuration settings that are specific to Azure
// load balancers.
//
// If empty, defaults will be applied. See specific azure fields for
// details about their defaults.
//
// +optional
Azure *AzureLoadBalancerParameters `json:"azure,omitempty"`
// GCP provides configuration settings that are specific to GCP
// load balancers.
//
// If empty, defaults will be applied. See specific gcp fields for
// details about their defaults.
//
// +optional
GCP *GCPLoadBalancerParameters `json:"gcp,omitempty"`
}
// LoadBalancerProviderType is the underlying infrastructure provider for the
// load balancer. Allowed values are "AWS", "Azure", and "GCP".
//
// +kubebuilder:validation:Enum=AWS;Azure;GCP
type LoadBalancerProviderType string
const (
AWSLoadBalancerProvider LoadBalancerProviderType = "AWS"
AzureLoadBalancerProvider LoadBalancerProviderType = "Azure"
GCPLoadBalancerProvider LoadBalancerProviderType = "GCP"
)
// AWSLoadBalancerParameters provides configuration settings that are specific to
// AWS load balancers.
type AWSLoadBalancerParameters struct {
// Type is the type of AWS load balancer to manage.
//
// Valid values are:
//
// * "Classic": A Classic load balancer makes routing decisions at either the
// transport layer (TCP/SSL) or the application layer (HTTP/HTTPS). See
// the following for additional details:
//
// https://docs.aws.amazon.com/AmazonECS/latest/developerguide/load-balancer-types.html#clb
//
// * "NLB": A Network load balancer makes routing decisions at the transport
// layer (TCP/SSL). See the following for additional details:
//
// https://docs.aws.amazon.com/AmazonECS/latest/developerguide/load-balancer-types.html#nlb
//
// If unset, defaults to "Classic".
//
// +kubebuilder:default=Classic
Type AWSLoadBalancerType `json:"type,omitempty"`
// AllocationIDs is a list of Allocation IDs of Elastic IP addresses that are
// to be assigned to the Network Load Balancer. Works only with type NLB.
// If you are using Amazon EKS 1.16 or later, you can assign Elastic IP addresses
// to Network Load Balancer with AllocationIDs. The number of Allocation IDs
// must match the number of subnets used for the load balancer.
//
// Example: "eipalloc-<xxxxxxxxxxxxxxxxx>"
//
// See: https://docs.aws.amazon.com/eks/latest/userguide/load-balancing.html
//
// +optional
AllocationIDs []string `json:"allocationIds,omitempty"`
}
// AWSLoadBalancerType is the type of AWS load balancer to manage.
// +kubebuilder:validation:Enum=Classic;NLB
type AWSLoadBalancerType string
const (
AWSClassicLoadBalancer AWSLoadBalancerType = "Classic"
AWSNetworkLoadBalancer AWSLoadBalancerType = "NLB"
)
type AzureLoadBalancerParameters struct {
// Address is the desired load balancer IP address. If scope is "Internal", address
// must reside in same virtual network as AKS and must not already be assigned
// to a resource. If address does not reside in same subnet as AKS, the subnet
// parameter is also required.
//
// Address must already exist (e.g. `az network public-ip create`).
//
// See:
// https://docs.microsoft.com/en-us/azure/aks/static-ip#create-a-service-using-the-static-ip-address
// https://docs.microsoft.com/en-us/azure/aks/internal-lb#specify-an-ip-address
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=253
// +optional
Address *string `json:"address,omitempty"`
// ResourceGroup is the resource group name where the "address" resides. Relevant
// only if scope is "External".
//
// Omit if desired IP is created in same resource group as AKS cluster.
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=90
// +optional
ResourceGroup *string `json:"resourceGroup,omitempty"`
// Subnet is the subnet name where the "address" resides. Relevant only
// if scope is "Internal" and desired IP does not reside in same subnet as AKS.
//
// Omit if desired IP is in same subnet as AKS cluster.
//
// See: https://docs.microsoft.com/en-us/azure/aks/internal-lb#specify-an-ip-address
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=80
// +optional
Subnet *string `json:"subnet,omitempty"`
}
type GCPLoadBalancerParameters struct {
// Address is the desired load balancer IP address. If scope is "Internal", the address
// must reside in same subnet as the GKE cluster or "subnet" has to be provided.
//
// See:
// https://cloud.google.com/kubernetes-engine/docs/tutorials/configuring-domain-name-static-ip#use_a_service
// https://cloud.google.com/kubernetes-engine/docs/how-to/internal-load-balancing#lb_subnet
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=253
// +optional
Address *string `json:"address,omitempty"`
// Subnet is the subnet name where the "address" resides. Relevant only
// if scope is "Internal" and desired IP does not reside in same subnet as GKE
// cluster.
//
// Omit if desired IP is in same subnet as GKE cluster.
//
// See: https://cloud.google.com/kubernetes-engine/docs/how-to/internal-load-balancing#lb_subnet
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=63
// +optional
Subnet *string `json:"subnet,omitempty"`
}
// NodePort is the schema to specify a network port for a NodePort Service.
type NodePort struct {
// Name is an IANA_SVC_NAME within the NodePort Service.
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=253
Name string `json:"name"`
// PortNumber is the network port number to expose for the NodePort Service.
// If unspecified, a port number will be assigned from the the cluster's
// nodeport service range, i.e. --service-node-port-range flag
// (default: 30000-32767).
//
// If specified, the number must:
//
// 1. Not be used by another NodePort Service.
// 2. Be within the cluster's nodeport service range, i.e. --service-node-port-range
// flag (default: 30000-32767).
// 3. Be a valid network port number, i.e. greater than 0 and less than 65536.
//
// +optional
// +kubebuilder:validation:Minimum=1
// +kubebuilder:validation:Maximum=65535
PortNumber *int32 `json:"portNumber,omitempty"`
}
// ContainerPort is the schema to specify a network port for a container.
// A container port gives the system additional information about network
// connections a container uses, but is primarily informational.
type ContainerPort struct {
// Name is an IANA_SVC_NAME within the pod.
//
// +kubebuilder:validation:MinLength=1
// +kubebuilder:validation:MaxLength=253
Name string `json:"name"`
// PortNumber is the network port number to expose on the envoy pod.
// The number must be greater than 0 and less than 65536.
// +kubebuilder:validation:Minimum=1
// +kubebuilder:validation:Maximum=65535
PortNumber int32 `json:"portNumber"`
}
const (
// ContourAvailableConditionType indicates that the contour is running
// and available.
ContourAvailableConditionType = "Available"
)
// ContourStatus defines the observed state of Contour.
type ContourStatus struct {
// AvailableContours is the number of observed available replicas
// according to the Contour deployment. The deployment and its pods
// will reside in the namespace specified by spec.namespace.name of
// the contour.
AvailableContours int32 `json:"availableContours"`
// AvailableEnvoys is the number of observed available pods from
// the Envoy daemonset. The daemonset and its pods will reside in the
// namespace specified by spec.namespace.name of the contour.
AvailableEnvoys int32 `json:"availableEnvoys"`
// Conditions represent the observations of a contour's current state.
// Known condition types are "Available". Reference the condition type
// for additional details.
//
// +patchMergeKey=type
// +patchStrategy=merge
// +listType=map
// +listMapKey=type
Conditions []metav1.Condition `json:"conditions,omitempty"`
}
func init() {
SchemeBuilder.Register(&Contour{}, &ContourList{})
}