diff --git a/pkg/apis/experimental/deep_copy_generated.go b/pkg/apis/experimental/deep_copy_generated.go index 3d7dd395998..d604a267afe 100644 --- a/pkg/apis/experimental/deep_copy_generated.go +++ b/pkg/apis/experimental/deep_copy_generated.go @@ -966,6 +966,28 @@ func deepCopy_experimental_DeploymentStrategy(in DeploymentStrategy, out *Deploy return nil } +func deepCopy_experimental_HTTPIngressPath(in HTTPIngressPath, out *HTTPIngressPath, c *conversion.Cloner) error { + out.Path = in.Path + if err := deepCopy_experimental_IngressBackend(in.Backend, &out.Backend, c); err != nil { + return err + } + return nil +} + +func deepCopy_experimental_HTTPIngressRuleValue(in HTTPIngressRuleValue, out *HTTPIngressRuleValue, c *conversion.Cloner) error { + if in.Paths != nil { + out.Paths = make([]HTTPIngressPath, len(in.Paths)) + for i := range in.Paths { + if err := deepCopy_experimental_HTTPIngressPath(in.Paths[i], &out.Paths[i], c); err != nil { + return err + } + } + } else { + out.Paths = nil + } + return nil +} + func deepCopy_experimental_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error { if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { return err @@ -1063,13 +1085,10 @@ func deepCopy_experimental_Ingress(in Ingress, out *Ingress, c *conversion.Clone } func deepCopy_experimental_IngressBackend(in IngressBackend, out *IngressBackend, c *conversion.Cloner) error { - if err := deepCopy_api_LocalObjectReference(in.ServiceRef, &out.ServiceRef, c); err != nil { - return err - } + out.ServiceName = in.ServiceName if err := deepCopy_util_IntOrString(in.ServicePort, &out.ServicePort, c); err != nil { return err } - out.Protocol = in.Protocol return nil } @@ -1093,30 +1112,35 @@ func deepCopy_experimental_IngressList(in IngressList, out *IngressList, c *conv return nil } -func deepCopy_experimental_IngressPath(in IngressPath, out *IngressPath, c *conversion.Cloner) error { - out.Path = in.Path - if err := deepCopy_experimental_IngressBackend(in.Backend, &out.Backend, c); err != nil { +func deepCopy_experimental_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error { + out.Host = in.Host + if err := deepCopy_experimental_IngressRuleValue(in.IngressRuleValue, &out.IngressRuleValue, c); err != nil { return err } return nil } -func deepCopy_experimental_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error { - out.Host = in.Host - if in.Paths != nil { - out.Paths = make([]IngressPath, len(in.Paths)) - for i := range in.Paths { - if err := deepCopy_experimental_IngressPath(in.Paths[i], &out.Paths[i], c); err != nil { - return err - } +func deepCopy_experimental_IngressRuleValue(in IngressRuleValue, out *IngressRuleValue, c *conversion.Cloner) error { + if in.HTTP != nil { + out.HTTP = new(HTTPIngressRuleValue) + if err := deepCopy_experimental_HTTPIngressRuleValue(*in.HTTP, out.HTTP, c); err != nil { + return err } } else { - out.Paths = nil + out.HTTP = nil } return nil } func deepCopy_experimental_IngressSpec(in IngressSpec, out *IngressSpec, c *conversion.Cloner) error { + if in.Backend != nil { + out.Backend = new(IngressBackend) + if err := deepCopy_experimental_IngressBackend(*in.Backend, out.Backend, c); err != nil { + return err + } + } else { + out.Backend = nil + } if in.Rules != nil { out.Rules = make([]IngressRule, len(in.Rules)) for i := range in.Rules { @@ -1463,6 +1487,8 @@ func init() { deepCopy_experimental_DeploymentSpec, deepCopy_experimental_DeploymentStatus, deepCopy_experimental_DeploymentStrategy, + deepCopy_experimental_HTTPIngressPath, + deepCopy_experimental_HTTPIngressRuleValue, deepCopy_experimental_HorizontalPodAutoscaler, deepCopy_experimental_HorizontalPodAutoscalerList, deepCopy_experimental_HorizontalPodAutoscalerSpec, @@ -1470,8 +1496,8 @@ func init() { deepCopy_experimental_Ingress, deepCopy_experimental_IngressBackend, deepCopy_experimental_IngressList, - deepCopy_experimental_IngressPath, deepCopy_experimental_IngressRule, + deepCopy_experimental_IngressRuleValue, deepCopy_experimental_IngressSpec, deepCopy_experimental_IngressStatus, deepCopy_experimental_Job, diff --git a/pkg/apis/experimental/v1alpha1/conversion_generated.go b/pkg/apis/experimental/v1alpha1/conversion_generated.go index 41571931653..56ec48737fb 100644 --- a/pkg/apis/experimental/v1alpha1/conversion_generated.go +++ b/pkg/apis/experimental/v1alpha1/conversion_generated.go @@ -2296,6 +2296,42 @@ func autoconvert_experimental_DeploymentStrategy_To_v1alpha1_DeploymentStrategy( return nil } +func autoconvert_experimental_HTTPIngressPath_To_v1alpha1_HTTPIngressPath(in *experimental.HTTPIngressPath, out *HTTPIngressPath, s conversion.Scope) error { + if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { + defaulting.(func(*experimental.HTTPIngressPath))(in) + } + out.Path = in.Path + if err := convert_experimental_IngressBackend_To_v1alpha1_IngressBackend(&in.Backend, &out.Backend, s); err != nil { + return err + } + return nil +} + +func convert_experimental_HTTPIngressPath_To_v1alpha1_HTTPIngressPath(in *experimental.HTTPIngressPath, out *HTTPIngressPath, s conversion.Scope) error { + return autoconvert_experimental_HTTPIngressPath_To_v1alpha1_HTTPIngressPath(in, out, s) +} + +func autoconvert_experimental_HTTPIngressRuleValue_To_v1alpha1_HTTPIngressRuleValue(in *experimental.HTTPIngressRuleValue, out *HTTPIngressRuleValue, s conversion.Scope) error { + if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { + defaulting.(func(*experimental.HTTPIngressRuleValue))(in) + } + if in.Paths != nil { + out.Paths = make([]HTTPIngressPath, len(in.Paths)) + for i := range in.Paths { + if err := convert_experimental_HTTPIngressPath_To_v1alpha1_HTTPIngressPath(&in.Paths[i], &out.Paths[i], s); err != nil { + return err + } + } + } else { + out.Paths = nil + } + return nil +} + +func convert_experimental_HTTPIngressRuleValue_To_v1alpha1_HTTPIngressRuleValue(in *experimental.HTTPIngressRuleValue, out *HTTPIngressRuleValue, s conversion.Scope) error { + return autoconvert_experimental_HTTPIngressRuleValue_To_v1alpha1_HTTPIngressRuleValue(in, out, s) +} + func autoconvert_experimental_HorizontalPodAutoscaler_To_v1alpha1_HorizontalPodAutoscaler(in *experimental.HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*experimental.HorizontalPodAutoscaler))(in) @@ -2430,13 +2466,10 @@ func autoconvert_experimental_IngressBackend_To_v1alpha1_IngressBackend(in *expe if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*experimental.IngressBackend))(in) } - if err := convert_api_LocalObjectReference_To_v1_LocalObjectReference(&in.ServiceRef, &out.ServiceRef, s); err != nil { - return err - } + out.ServiceName = in.ServiceName if err := s.Convert(&in.ServicePort, &out.ServicePort, 0); err != nil { return err } - out.Protocol = v1.Protocol(in.Protocol) return nil } @@ -2471,35 +2504,13 @@ func convert_experimental_IngressList_To_v1alpha1_IngressList(in *experimental.I return autoconvert_experimental_IngressList_To_v1alpha1_IngressList(in, out, s) } -func autoconvert_experimental_IngressPath_To_v1alpha1_IngressPath(in *experimental.IngressPath, out *IngressPath, s conversion.Scope) error { - if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { - defaulting.(func(*experimental.IngressPath))(in) - } - out.Path = in.Path - if err := convert_experimental_IngressBackend_To_v1alpha1_IngressBackend(&in.Backend, &out.Backend, s); err != nil { - return err - } - return nil -} - -func convert_experimental_IngressPath_To_v1alpha1_IngressPath(in *experimental.IngressPath, out *IngressPath, s conversion.Scope) error { - return autoconvert_experimental_IngressPath_To_v1alpha1_IngressPath(in, out, s) -} - func autoconvert_experimental_IngressRule_To_v1alpha1_IngressRule(in *experimental.IngressRule, out *IngressRule, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*experimental.IngressRule))(in) } out.Host = in.Host - if in.Paths != nil { - out.Paths = make([]IngressPath, len(in.Paths)) - for i := range in.Paths { - if err := convert_experimental_IngressPath_To_v1alpha1_IngressPath(&in.Paths[i], &out.Paths[i], s); err != nil { - return err - } - } - } else { - out.Paths = nil + if err := convert_experimental_IngressRuleValue_To_v1alpha1_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil { + return err } return nil } @@ -2508,10 +2519,37 @@ func convert_experimental_IngressRule_To_v1alpha1_IngressRule(in *experimental.I return autoconvert_experimental_IngressRule_To_v1alpha1_IngressRule(in, out, s) } +func autoconvert_experimental_IngressRuleValue_To_v1alpha1_IngressRuleValue(in *experimental.IngressRuleValue, out *IngressRuleValue, s conversion.Scope) error { + if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { + defaulting.(func(*experimental.IngressRuleValue))(in) + } + if in.HTTP != nil { + out.HTTP = new(HTTPIngressRuleValue) + if err := convert_experimental_HTTPIngressRuleValue_To_v1alpha1_HTTPIngressRuleValue(in.HTTP, out.HTTP, s); err != nil { + return err + } + } else { + out.HTTP = nil + } + return nil +} + +func convert_experimental_IngressRuleValue_To_v1alpha1_IngressRuleValue(in *experimental.IngressRuleValue, out *IngressRuleValue, s conversion.Scope) error { + return autoconvert_experimental_IngressRuleValue_To_v1alpha1_IngressRuleValue(in, out, s) +} + func autoconvert_experimental_IngressSpec_To_v1alpha1_IngressSpec(in *experimental.IngressSpec, out *IngressSpec, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*experimental.IngressSpec))(in) } + if in.Backend != nil { + out.Backend = new(IngressBackend) + if err := convert_experimental_IngressBackend_To_v1alpha1_IngressBackend(in.Backend, out.Backend, s); err != nil { + return err + } + } else { + out.Backend = nil + } if in.Rules != nil { out.Rules = make([]IngressRule, len(in.Rules)) for i := range in.Rules { @@ -3102,6 +3140,42 @@ func convert_v1alpha1_DeploymentStatus_To_experimental_DeploymentStatus(in *Depl return autoconvert_v1alpha1_DeploymentStatus_To_experimental_DeploymentStatus(in, out, s) } +func autoconvert_v1alpha1_HTTPIngressPath_To_experimental_HTTPIngressPath(in *HTTPIngressPath, out *experimental.HTTPIngressPath, s conversion.Scope) error { + if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { + defaulting.(func(*HTTPIngressPath))(in) + } + out.Path = in.Path + if err := convert_v1alpha1_IngressBackend_To_experimental_IngressBackend(&in.Backend, &out.Backend, s); err != nil { + return err + } + return nil +} + +func convert_v1alpha1_HTTPIngressPath_To_experimental_HTTPIngressPath(in *HTTPIngressPath, out *experimental.HTTPIngressPath, s conversion.Scope) error { + return autoconvert_v1alpha1_HTTPIngressPath_To_experimental_HTTPIngressPath(in, out, s) +} + +func autoconvert_v1alpha1_HTTPIngressRuleValue_To_experimental_HTTPIngressRuleValue(in *HTTPIngressRuleValue, out *experimental.HTTPIngressRuleValue, s conversion.Scope) error { + if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { + defaulting.(func(*HTTPIngressRuleValue))(in) + } + if in.Paths != nil { + out.Paths = make([]experimental.HTTPIngressPath, len(in.Paths)) + for i := range in.Paths { + if err := convert_v1alpha1_HTTPIngressPath_To_experimental_HTTPIngressPath(&in.Paths[i], &out.Paths[i], s); err != nil { + return err + } + } + } else { + out.Paths = nil + } + return nil +} + +func convert_v1alpha1_HTTPIngressRuleValue_To_experimental_HTTPIngressRuleValue(in *HTTPIngressRuleValue, out *experimental.HTTPIngressRuleValue, s conversion.Scope) error { + return autoconvert_v1alpha1_HTTPIngressRuleValue_To_experimental_HTTPIngressRuleValue(in, out, s) +} + func autoconvert_v1alpha1_HorizontalPodAutoscaler_To_experimental_HorizontalPodAutoscaler(in *HorizontalPodAutoscaler, out *experimental.HorizontalPodAutoscaler, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*HorizontalPodAutoscaler))(in) @@ -3236,13 +3310,10 @@ func autoconvert_v1alpha1_IngressBackend_To_experimental_IngressBackend(in *Ingr if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*IngressBackend))(in) } - if err := convert_v1_LocalObjectReference_To_api_LocalObjectReference(&in.ServiceRef, &out.ServiceRef, s); err != nil { - return err - } + out.ServiceName = in.ServiceName if err := s.Convert(&in.ServicePort, &out.ServicePort, 0); err != nil { return err } - out.Protocol = api.Protocol(in.Protocol) return nil } @@ -3277,35 +3348,13 @@ func convert_v1alpha1_IngressList_To_experimental_IngressList(in *IngressList, o return autoconvert_v1alpha1_IngressList_To_experimental_IngressList(in, out, s) } -func autoconvert_v1alpha1_IngressPath_To_experimental_IngressPath(in *IngressPath, out *experimental.IngressPath, s conversion.Scope) error { - if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { - defaulting.(func(*IngressPath))(in) - } - out.Path = in.Path - if err := convert_v1alpha1_IngressBackend_To_experimental_IngressBackend(&in.Backend, &out.Backend, s); err != nil { - return err - } - return nil -} - -func convert_v1alpha1_IngressPath_To_experimental_IngressPath(in *IngressPath, out *experimental.IngressPath, s conversion.Scope) error { - return autoconvert_v1alpha1_IngressPath_To_experimental_IngressPath(in, out, s) -} - func autoconvert_v1alpha1_IngressRule_To_experimental_IngressRule(in *IngressRule, out *experimental.IngressRule, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*IngressRule))(in) } out.Host = in.Host - if in.Paths != nil { - out.Paths = make([]experimental.IngressPath, len(in.Paths)) - for i := range in.Paths { - if err := convert_v1alpha1_IngressPath_To_experimental_IngressPath(&in.Paths[i], &out.Paths[i], s); err != nil { - return err - } - } - } else { - out.Paths = nil + if err := convert_v1alpha1_IngressRuleValue_To_experimental_IngressRuleValue(&in.IngressRuleValue, &out.IngressRuleValue, s); err != nil { + return err } return nil } @@ -3314,10 +3363,37 @@ func convert_v1alpha1_IngressRule_To_experimental_IngressRule(in *IngressRule, o return autoconvert_v1alpha1_IngressRule_To_experimental_IngressRule(in, out, s) } +func autoconvert_v1alpha1_IngressRuleValue_To_experimental_IngressRuleValue(in *IngressRuleValue, out *experimental.IngressRuleValue, s conversion.Scope) error { + if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { + defaulting.(func(*IngressRuleValue))(in) + } + if in.HTTP != nil { + out.HTTP = new(experimental.HTTPIngressRuleValue) + if err := convert_v1alpha1_HTTPIngressRuleValue_To_experimental_HTTPIngressRuleValue(in.HTTP, out.HTTP, s); err != nil { + return err + } + } else { + out.HTTP = nil + } + return nil +} + +func convert_v1alpha1_IngressRuleValue_To_experimental_IngressRuleValue(in *IngressRuleValue, out *experimental.IngressRuleValue, s conversion.Scope) error { + return autoconvert_v1alpha1_IngressRuleValue_To_experimental_IngressRuleValue(in, out, s) +} + func autoconvert_v1alpha1_IngressSpec_To_experimental_IngressSpec(in *IngressSpec, out *experimental.IngressSpec, s conversion.Scope) error { if defaulting, found := s.DefaultingInterface(reflect.TypeOf(*in)); found { defaulting.(func(*IngressSpec))(in) } + if in.Backend != nil { + out.Backend = new(experimental.IngressBackend) + if err := convert_v1alpha1_IngressBackend_To_experimental_IngressBackend(in.Backend, out.Backend, s); err != nil { + return err + } + } else { + out.Backend = nil + } if in.Rules != nil { out.Rules = make([]experimental.IngressRule, len(in.Rules)) for i := range in.Rules { @@ -3761,13 +3837,15 @@ func init() { autoconvert_experimental_DeploymentStatus_To_v1alpha1_DeploymentStatus, autoconvert_experimental_DeploymentStrategy_To_v1alpha1_DeploymentStrategy, autoconvert_experimental_Deployment_To_v1alpha1_Deployment, + autoconvert_experimental_HTTPIngressPath_To_v1alpha1_HTTPIngressPath, + autoconvert_experimental_HTTPIngressRuleValue_To_v1alpha1_HTTPIngressRuleValue, autoconvert_experimental_HorizontalPodAutoscalerList_To_v1alpha1_HorizontalPodAutoscalerList, autoconvert_experimental_HorizontalPodAutoscalerSpec_To_v1alpha1_HorizontalPodAutoscalerSpec, autoconvert_experimental_HorizontalPodAutoscalerStatus_To_v1alpha1_HorizontalPodAutoscalerStatus, autoconvert_experimental_HorizontalPodAutoscaler_To_v1alpha1_HorizontalPodAutoscaler, autoconvert_experimental_IngressBackend_To_v1alpha1_IngressBackend, autoconvert_experimental_IngressList_To_v1alpha1_IngressList, - autoconvert_experimental_IngressPath_To_v1alpha1_IngressPath, + autoconvert_experimental_IngressRuleValue_To_v1alpha1_IngressRuleValue, autoconvert_experimental_IngressRule_To_v1alpha1_IngressRule, autoconvert_experimental_IngressSpec_To_v1alpha1_IngressSpec, autoconvert_experimental_IngressStatus_To_v1alpha1_IngressStatus, @@ -3837,13 +3915,15 @@ func init() { autoconvert_v1alpha1_DeploymentSpec_To_experimental_DeploymentSpec, autoconvert_v1alpha1_DeploymentStatus_To_experimental_DeploymentStatus, autoconvert_v1alpha1_Deployment_To_experimental_Deployment, + autoconvert_v1alpha1_HTTPIngressPath_To_experimental_HTTPIngressPath, + autoconvert_v1alpha1_HTTPIngressRuleValue_To_experimental_HTTPIngressRuleValue, autoconvert_v1alpha1_HorizontalPodAutoscalerList_To_experimental_HorizontalPodAutoscalerList, autoconvert_v1alpha1_HorizontalPodAutoscalerSpec_To_experimental_HorizontalPodAutoscalerSpec, autoconvert_v1alpha1_HorizontalPodAutoscalerStatus_To_experimental_HorizontalPodAutoscalerStatus, autoconvert_v1alpha1_HorizontalPodAutoscaler_To_experimental_HorizontalPodAutoscaler, autoconvert_v1alpha1_IngressBackend_To_experimental_IngressBackend, autoconvert_v1alpha1_IngressList_To_experimental_IngressList, - autoconvert_v1alpha1_IngressPath_To_experimental_IngressPath, + autoconvert_v1alpha1_IngressRuleValue_To_experimental_IngressRuleValue, autoconvert_v1alpha1_IngressRule_To_experimental_IngressRule, autoconvert_v1alpha1_IngressSpec_To_experimental_IngressSpec, autoconvert_v1alpha1_IngressStatus_To_experimental_IngressStatus, diff --git a/pkg/apis/experimental/v1alpha1/deep_copy_generated.go b/pkg/apis/experimental/v1alpha1/deep_copy_generated.go index 8df29457d7d..95864db7027 100644 --- a/pkg/apis/experimental/v1alpha1/deep_copy_generated.go +++ b/pkg/apis/experimental/v1alpha1/deep_copy_generated.go @@ -978,6 +978,28 @@ func deepCopy_v1alpha1_DeploymentStrategy(in DeploymentStrategy, out *Deployment return nil } +func deepCopy_v1alpha1_HTTPIngressPath(in HTTPIngressPath, out *HTTPIngressPath, c *conversion.Cloner) error { + out.Path = in.Path + if err := deepCopy_v1alpha1_IngressBackend(in.Backend, &out.Backend, c); err != nil { + return err + } + return nil +} + +func deepCopy_v1alpha1_HTTPIngressRuleValue(in HTTPIngressRuleValue, out *HTTPIngressRuleValue, c *conversion.Cloner) error { + if in.Paths != nil { + out.Paths = make([]HTTPIngressPath, len(in.Paths)) + for i := range in.Paths { + if err := deepCopy_v1alpha1_HTTPIngressPath(in.Paths[i], &out.Paths[i], c); err != nil { + return err + } + } + } else { + out.Paths = nil + } + return nil +} + func deepCopy_v1alpha1_HorizontalPodAutoscaler(in HorizontalPodAutoscaler, out *HorizontalPodAutoscaler, c *conversion.Cloner) error { if err := deepCopy_unversioned_TypeMeta(in.TypeMeta, &out.TypeMeta, c); err != nil { return err @@ -1075,13 +1097,10 @@ func deepCopy_v1alpha1_Ingress(in Ingress, out *Ingress, c *conversion.Cloner) e } func deepCopy_v1alpha1_IngressBackend(in IngressBackend, out *IngressBackend, c *conversion.Cloner) error { - if err := deepCopy_v1_LocalObjectReference(in.ServiceRef, &out.ServiceRef, c); err != nil { - return err - } + out.ServiceName = in.ServiceName if err := deepCopy_util_IntOrString(in.ServicePort, &out.ServicePort, c); err != nil { return err } - out.Protocol = in.Protocol return nil } @@ -1105,30 +1124,35 @@ func deepCopy_v1alpha1_IngressList(in IngressList, out *IngressList, c *conversi return nil } -func deepCopy_v1alpha1_IngressPath(in IngressPath, out *IngressPath, c *conversion.Cloner) error { - out.Path = in.Path - if err := deepCopy_v1alpha1_IngressBackend(in.Backend, &out.Backend, c); err != nil { +func deepCopy_v1alpha1_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error { + out.Host = in.Host + if err := deepCopy_v1alpha1_IngressRuleValue(in.IngressRuleValue, &out.IngressRuleValue, c); err != nil { return err } return nil } -func deepCopy_v1alpha1_IngressRule(in IngressRule, out *IngressRule, c *conversion.Cloner) error { - out.Host = in.Host - if in.Paths != nil { - out.Paths = make([]IngressPath, len(in.Paths)) - for i := range in.Paths { - if err := deepCopy_v1alpha1_IngressPath(in.Paths[i], &out.Paths[i], c); err != nil { - return err - } +func deepCopy_v1alpha1_IngressRuleValue(in IngressRuleValue, out *IngressRuleValue, c *conversion.Cloner) error { + if in.HTTP != nil { + out.HTTP = new(HTTPIngressRuleValue) + if err := deepCopy_v1alpha1_HTTPIngressRuleValue(*in.HTTP, out.HTTP, c); err != nil { + return err } } else { - out.Paths = nil + out.HTTP = nil } return nil } func deepCopy_v1alpha1_IngressSpec(in IngressSpec, out *IngressSpec, c *conversion.Cloner) error { + if in.Backend != nil { + out.Backend = new(IngressBackend) + if err := deepCopy_v1alpha1_IngressBackend(*in.Backend, out.Backend, c); err != nil { + return err + } + } else { + out.Backend = nil + } if in.Rules != nil { out.Rules = make([]IngressRule, len(in.Rules)) for i := range in.Rules { @@ -1485,6 +1509,8 @@ func init() { deepCopy_v1alpha1_DeploymentSpec, deepCopy_v1alpha1_DeploymentStatus, deepCopy_v1alpha1_DeploymentStrategy, + deepCopy_v1alpha1_HTTPIngressPath, + deepCopy_v1alpha1_HTTPIngressRuleValue, deepCopy_v1alpha1_HorizontalPodAutoscaler, deepCopy_v1alpha1_HorizontalPodAutoscalerList, deepCopy_v1alpha1_HorizontalPodAutoscalerSpec, @@ -1492,8 +1518,8 @@ func init() { deepCopy_v1alpha1_Ingress, deepCopy_v1alpha1_IngressBackend, deepCopy_v1alpha1_IngressList, - deepCopy_v1alpha1_IngressPath, deepCopy_v1alpha1_IngressRule, + deepCopy_v1alpha1_IngressRuleValue, deepCopy_v1alpha1_IngressSpec, deepCopy_v1alpha1_IngressStatus, deepCopy_v1alpha1_Job, diff --git a/pkg/apis/experimental/v1alpha1/types_swagger_doc_generated.go b/pkg/apis/experimental/v1alpha1/types_swagger_doc_generated.go index 72cd60d56fa..72632920868 100644 --- a/pkg/apis/experimental/v1alpha1/types_swagger_doc_generated.go +++ b/pkg/apis/experimental/v1alpha1/types_swagger_doc_generated.go @@ -133,6 +133,25 @@ func (DeploymentStrategy) SwaggerDoc() map[string]string { return map_DeploymentStrategy } +var map_HTTPIngressPath = map[string]string{ + "": "IngressPath associates a path regex with an IngressBackend. Incoming urls matching the Path are forwarded to the Backend.", + "path": "Path is a regex matched against the url of an incoming request.", + "backend": "Define the referenced service endpoint which the traffic will be forwarded to.", +} + +func (HTTPIngressPath) SwaggerDoc() map[string]string { + return map_HTTPIngressPath +} + +var map_HTTPIngressRuleValue = map[string]string{ + "": "HTTPIngressRuleValue is a list of http selectors pointing to IngressBackends. In the example: http:///? -> IngressBackend where parts of the url correspond to RFC 3986, this resource will be used to to match against everything after the last '/' and before the first '?' or '#'.", + "paths": "A collection of paths that map requests to IngressBackends.", +} + +func (HTTPIngressRuleValue) SwaggerDoc() map[string]string { + return map_HTTPIngressRuleValue +} + var map_HorizontalPodAutoscaler = map[string]string{ "": "HorizontalPodAutoscaler represents the configuration of a horizontal pod autoscaler.", "metadata": "Standard object metadata. More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata", @@ -179,7 +198,7 @@ func (HorizontalPodAutoscalerStatus) SwaggerDoc() map[string]string { } var map_Ingress = map[string]string{ - "": "An Ingress is a way to give services externally-reachable urls. Each Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend.", + "": "Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give services externally-reachable urls, load balance traffic, terminate SSL, offer name based virtual hosting etc.", "metadata": "Standard object's metadata. More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata", "spec": "Spec is the desired state of the Ingress. More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#spec-and-status", "status": "Status is the current state of the Ingress. More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#spec-and-status", @@ -190,10 +209,9 @@ func (Ingress) SwaggerDoc() map[string]string { } var map_IngressBackend = map[string]string{ - "": "IngressBackend describes all endpoints for a given Service, port and protocol.", - "serviceRef": "Specifies the referenced service.", + "": "IngressBackend describes all endpoints for a given Service and port.", + "serviceName": "Specifies the name of the referenced service.", "servicePort": "Specifies the port of the referenced service.", - "protocol": "Specifies the protocol of the referenced service.", } func (IngressBackend) SwaggerDoc() map[string]string { @@ -210,29 +228,28 @@ func (IngressList) SwaggerDoc() map[string]string { return map_IngressList } -var map_IngressPath = map[string]string{ - "": "IngressPath associates a path regex with an IngressBackend. Incoming urls matching the Path are forwarded to the Backend.", - "path": "Path is a regex matched against the url of an incoming request.", - "backend": "Define the referenced service endpoint which the traffic will be forwarded to.", -} - -func (IngressPath) SwaggerDoc() map[string]string { - return map_IngressPath -} - var map_IngressRule = map[string]string{ - "": "IngressRule represents the rules mapping the paths under a specified host to the related backend services.", - "host": "Host is the fully qualified domain name of a network host, or its IP address as a set of four decimal digit groups separated by \".\". Conforms to RFC 1738.", - "paths": "Paths describe a list of load-balancer rules under the specified host.", + "": "IngressRule represents the rules mapping the paths under a specified host to the related backend services.", + "host": "Host is the fully qualified domain name of a network host, as defined by RFC 3986. Note the following deviations from the \"host\" part of the URI as defined in the RFC: 1. IPs are not allowed. Currently an IngressRuleValue can only apply to the\n\t IP in the Spec of the parent Ingress.\n2. The `:` delimiter is not respected because ports are not allowed.\n\t Currently the port of an Ingress is implicitly :80 for http and\n\t :443 for https.\nBoth these may change in the future. Incoming requests are matched against the Host before the IngressRuleValue.", } func (IngressRule) SwaggerDoc() map[string]string { return map_IngressRule } +var map_IngressRuleValue = map[string]string{ + "": "IngressRuleValue represents a rule to apply against incoming requests. If the rule is satisfied, the request is routed to the specified backend.", + "http": "Currently mixing different types of rules in a single Ingress is disallowed, so exactly one of the following must be set.", +} + +func (IngressRuleValue) SwaggerDoc() map[string]string { + return map_IngressRuleValue +} + var map_IngressSpec = map[string]string{ - "": "IngressSpec describes the Ingress the user wishes to exist.", - "rules": "A list of rules used to configure the Ingress. http://:/? -> IngressBackend Where parts of the url conform to RFC 1738.", + "": "IngressSpec describes the Ingress the user wishes to exist.", + "backend": "A default backend capable of servicing requests that don't match any IngressRule. It is optional to allow the loadbalancer controller or defaulting logic to specify a global default.", + "rules": "A list of host rules used to configure the Ingress.", } func (IngressSpec) SwaggerDoc() map[string]string {