conversion.go

Documentation: k8s.io/kubernetes/pkg/apis/extensions/v1beta1

     1  /*
     2  Copyright 2015 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package v1beta1
    18  
    19  import (
    20  	"fmt"
    21  
    22  	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
    23  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    24  	"k8s.io/apimachinery/pkg/conversion"
    25  	"k8s.io/apimachinery/pkg/labels"
    26  	"k8s.io/apimachinery/pkg/util/intstr"
    27  	"k8s.io/kubernetes/pkg/apis/autoscaling"
    28  	"k8s.io/kubernetes/pkg/apis/networking"
    29  )
    30  
    31  func Convert_autoscaling_ScaleStatus_To_v1beta1_ScaleStatus(in *autoscaling.ScaleStatus, out *extensionsv1beta1.ScaleStatus, s conversion.Scope) error {
    32  	out.Replicas = int32(in.Replicas)
    33  	out.TargetSelector = in.Selector
    34  
    35  	out.Selector = nil
    36  	selector, err := metav1.ParseToLabelSelector(in.Selector)
    37  	if err != nil {
    38  		return fmt.Errorf("failed to parse selector: %v", err)
    39  	}
    40  	if len(selector.MatchExpressions) == 0 {
    41  		out.Selector = selector.MatchLabels
    42  	}
    43  
    44  	return nil
    45  }
    46  
    47  func Convert_v1beta1_ScaleStatus_To_autoscaling_ScaleStatus(in *extensionsv1beta1.ScaleStatus, out *autoscaling.ScaleStatus, s conversion.Scope) error {
    48  	out.Replicas = in.Replicas
    49  
    50  	if in.TargetSelector != "" {
    51  		out.Selector = in.TargetSelector
    52  	} else if in.Selector != nil {
    53  		set := labels.Set{}
    54  		for key, val := range in.Selector {
    55  			set[key] = val
    56  		}
    57  		out.Selector = labels.SelectorFromSet(set).String()
    58  	} else {
    59  		out.Selector = ""
    60  	}
    61  	return nil
    62  }
    63  
    64  func Convert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(in *extensionsv1beta1.NetworkPolicySpec, out *networking.NetworkPolicySpec, s conversion.Scope) error {
    65  	if err := autoConvert_v1beta1_NetworkPolicySpec_To_networking_NetworkPolicySpec(in, out, s); err != nil {
    66  		return err
    67  	}
    68  	if out.Ingress == nil {
    69  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
    70  		out.Ingress = make([]networking.NetworkPolicyIngressRule, 0)
    71  	}
    72  	if out.Egress == nil {
    73  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
    74  		out.Egress = make([]networking.NetworkPolicyEgressRule, 0)
    75  	}
    76  	return nil
    77  }
    78  
    79  func Convert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in *networking.NetworkPolicySpec, out *extensionsv1beta1.NetworkPolicySpec, s conversion.Scope) error {
    80  	if err := autoConvert_networking_NetworkPolicySpec_To_v1beta1_NetworkPolicySpec(in, out, s); err != nil {
    81  		return err
    82  	}
    83  	if out.Ingress == nil {
    84  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
    85  		out.Ingress = make([]extensionsv1beta1.NetworkPolicyIngressRule, 0)
    86  	}
    87  	if out.Egress == nil {
    88  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
    89  		out.Egress = make([]extensionsv1beta1.NetworkPolicyEgressRule, 0)
    90  	}
    91  	return nil
    92  }
    93  
    94  func Convert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(in *extensionsv1beta1.NetworkPolicyIngressRule, out *networking.NetworkPolicyIngressRule, s conversion.Scope) error {
    95  	if err := autoConvert_v1beta1_NetworkPolicyIngressRule_To_networking_NetworkPolicyIngressRule(in, out, s); err != nil {
    96  		return err
    97  	}
    98  	if out.Ports == nil {
    99  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
   100  		out.Ports = make([]networking.NetworkPolicyPort, 0)
   101  	}
   102  	return nil
   103  }
   104  
   105  func Convert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in *networking.NetworkPolicyIngressRule, out *extensionsv1beta1.NetworkPolicyIngressRule, s conversion.Scope) error {
   106  	if err := autoConvert_networking_NetworkPolicyIngressRule_To_v1beta1_NetworkPolicyIngressRule(in, out, s); err != nil {
   107  		return err
   108  	}
   109  	if out.Ports == nil {
   110  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
   111  		out.Ports = make([]extensionsv1beta1.NetworkPolicyPort, 0)
   112  	}
   113  	return nil
   114  }
   115  
   116  func Convert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(in *extensionsv1beta1.NetworkPolicyEgressRule, out *networking.NetworkPolicyEgressRule, s conversion.Scope) error {
   117  	if err := autoConvert_v1beta1_NetworkPolicyEgressRule_To_networking_NetworkPolicyEgressRule(in, out, s); err != nil {
   118  		return err
   119  	}
   120  	if out.Ports == nil {
   121  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
   122  		out.Ports = make([]networking.NetworkPolicyPort, 0)
   123  	}
   124  	if out.To == nil {
   125  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
   126  		out.To = make([]networking.NetworkPolicyPeer, 0)
   127  	}
   128  	return nil
   129  }
   130  
   131  func Convert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(in *networking.NetworkPolicyEgressRule, out *extensionsv1beta1.NetworkPolicyEgressRule, s conversion.Scope) error {
   132  	if err := autoConvert_networking_NetworkPolicyEgressRule_To_v1beta1_NetworkPolicyEgressRule(in, out, s); err != nil {
   133  		return err
   134  	}
   135  	if out.Ports == nil {
   136  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
   137  		out.Ports = make([]extensionsv1beta1.NetworkPolicyPort, 0)
   138  	}
   139  	if out.To == nil {
   140  		// Produce a zero-length non-nil slice for compatibility with previous manual conversion.
   141  		out.To = make([]extensionsv1beta1.NetworkPolicyPeer, 0)
   142  	}
   143  	return nil
   144  }
   145  
   146  func Convert_v1beta1_IPBlock_To_networking_IPBlock(in *extensionsv1beta1.IPBlock, out *networking.IPBlock, s conversion.Scope) error {
   147  	out.CIDR = in.CIDR
   148  
   149  	out.Except = make([]string, len(in.Except))
   150  	copy(out.Except, in.Except)
   151  	return nil
   152  }
   153  
   154  func Convert_networking_IPBlock_To_v1beta1_IPBlock(in *networking.IPBlock, out *extensionsv1beta1.IPBlock, s conversion.Scope) error {
   155  	out.CIDR = in.CIDR
   156  
   157  	out.Except = make([]string, len(in.Except))
   158  	copy(out.Except, in.Except)
   159  	return nil
   160  }
   161  
   162  func Convert_v1beta1_IngressBackend_To_networking_IngressBackend(in *extensionsv1beta1.IngressBackend, out *networking.IngressBackend, s conversion.Scope) error {
   163  	if err := autoConvert_v1beta1_IngressBackend_To_networking_IngressBackend(in, out, s); err != nil {
   164  		return err
   165  	}
   166  	if len(in.ServiceName) > 0 || in.ServicePort.IntVal != 0 || in.ServicePort.StrVal != "" || in.ServicePort.Type == intstr.String {
   167  		out.Service = &networking.IngressServiceBackend{}
   168  		out.Service.Name = in.ServiceName
   169  		out.Service.Port.Name = in.ServicePort.StrVal
   170  		out.Service.Port.Number = in.ServicePort.IntVal
   171  	}
   172  	return nil
   173  }
   174  
   175  func Convert_networking_IngressBackend_To_v1beta1_IngressBackend(in *networking.IngressBackend, out *extensionsv1beta1.IngressBackend, s conversion.Scope) error {
   176  	if err := autoConvert_networking_IngressBackend_To_v1beta1_IngressBackend(in, out, s); err != nil {
   177  		return err
   178  	}
   179  	if in.Service != nil {
   180  		out.ServiceName = in.Service.Name
   181  		if len(in.Service.Port.Name) > 0 {
   182  			out.ServicePort = intstr.FromString(in.Service.Port.Name)
   183  		} else {
   184  			out.ServicePort = intstr.FromInt32(in.Service.Port.Number)
   185  		}
   186  	}
   187  	return nil
   188  }
   189  
   190  func Convert_v1beta1_IngressSpec_To_networking_IngressSpec(in *extensionsv1beta1.IngressSpec, out *networking.IngressSpec, s conversion.Scope) error {
   191  	if err := autoConvert_v1beta1_IngressSpec_To_networking_IngressSpec(in, out, s); err != nil {
   192  		return err
   193  	}
   194  	if in.Backend != nil {
   195  		out.DefaultBackend = &networking.IngressBackend{}
   196  		if err := Convert_v1beta1_IngressBackend_To_networking_IngressBackend(in.Backend, out.DefaultBackend, s); err != nil {
   197  			return err
   198  		}
   199  	}
   200  	return nil
   201  }
   202  
   203  func Convert_networking_IngressSpec_To_v1beta1_IngressSpec(in *networking.IngressSpec, out *extensionsv1beta1.IngressSpec, s conversion.Scope) error {
   204  	if err := autoConvert_networking_IngressSpec_To_v1beta1_IngressSpec(in, out, s); err != nil {
   205  		return err
   206  	}
   207  	if in.DefaultBackend != nil {
   208  		out.Backend = &extensionsv1beta1.IngressBackend{}
   209  		if err := Convert_networking_IngressBackend_To_v1beta1_IngressBackend(in.DefaultBackend, out.Backend, s); err != nil {
   210  			return err
   211  		}
   212  	}
   213  	return nil
   214  }
   215
View as plain text